home *** CD-ROM | disk | FTP | other *** search
/ BBS in a Box 3 / BBS in a box - Trilogy III.iso / Files / Tele / C / Comet2.1.3 Folder / Comet / menu.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-10-30  |  67.7 KB  |  2,966 lines  |  [TEXT/MPS ]
  1. /*
  2.     Copyright Cornell University 1986.  All rights are reserved.
  3.     
  4.     menu.c contains routines which create, maintain, and allow access to 
  5.     items in the Macintosh menus.
  6. */
  7.  
  8. #include     <em.h>
  9.  
  10. #include    <3270.h>
  11. #include    <rcodes.h>
  12. #include    <h19.h>
  13.  
  14. #include     <h19.h>
  15. #include     <util.h>
  16. #include     <macdefs.h>
  17. #include     <resdefs.h>
  18. #include     <cntldefs.h>
  19. #include     <config.h>
  20. #include    "menudefs.h"
  21.  
  22. #include <net.h>            /* merged TCP */
  23. #ifdef DUALTCP
  24. #endif
  25.  
  26. #ifndef MACTCP
  27. #include    <tcp.h>
  28. #include    <tcpdefs.h>
  29. #endif
  30.  
  31. MenuHandle menu[NMENUS];
  32.  
  33. WindowPtr menuwindows[MAXWIND];
  34. short menuwindowcount;
  35.  
  36. char * seltext = "text";
  37. char * selscreen = "screen";
  38. char * selselection = "selection";
  39.  
  40. char * munderstr = "\PUse Underline Cursor";
  41. char * mblockstr = "\PUse Block Cursor";
  42. char * use9str = "\PUse 9 pt. font";
  43.  
  44. short darefnum;
  45. short appclosing;                        /* flag for updatewait() when quitting... */
  46. extern short pastemode;
  47.  
  48. /* in event.c */
  49. extern short autokeycommand;            /* autoKey menu commands use this flag to suppress menu flashing */
  50. extern EventRecord    myEvent;
  51.  
  52. extern     findstring();
  53. extern char fstring[];
  54.  
  55. #define FONTSIZECOUNT    3
  56.  
  57. char * bugnote = "\015A copy of the bug report form has been placed in the Clipboard, \
  58. so you can paste it into an editor or other application; please check the \
  59. About Comet... menu item for known bugs and palliatives.";
  60.  
  61. char * bugreport = "\
  62.                  Comet Bug Report:\015\
  63.         Mail to: comet-bugs@nmc.cit.cornell.edu\015\015\
  64.       Mac model: (Please note which adapter/monitor combination you use)\015\
  65.  System Version: \015\
  66.     MultiFinder: \015\
  67.           INITs: (Please list the INITs and drivers that are installed in your System Folder)\015\
  68.    Fast drawing: (ENABLED or DISABLED)\015\
  69.   Connection(s): (MacTCP LocalTalk, MacTCP EtherNet, and/or Serial)\015\
  70.       if MacTCP: (Use Asynchronous sends ENABLED or DISABLED--note that\015\
  71.                   MacTCP up to 1.0.2 crashes if this is enabled on LocalTalk)\015\
  72. Bug description: Using Comet 2.1.3 we observed...\015\
  73.           (If possible, please provide enough detail to reproduce the bug)\015";
  74.  
  75. docommand(mResult)
  76. long mResult;
  77. {
  78.     short theItem;
  79.     short theMenu;
  80.     char name[NAMESIZE];
  81.  
  82.     theMenu = mResult >> 16;
  83.     theItem = mResult;
  84.  
  85.     switch(theMenu) {
  86.         case applemenu: {
  87.             switch (theItem) {
  88.                 case ABOUT_COMET: {
  89.                     int tfont;
  90.                     int tsize;
  91.                     
  92.                     if (keydp != NULL) {
  93.                         tfont = keydp->normfont;
  94.                         tsize = keydp->fontsize;
  95.                     }
  96.                     else {
  97.                         tfont = FONTCUA;
  98.                         tsize = 9;
  99.                     }
  100.                     
  101.                     helpwindow(TEXTABOUT, tfont, tsize);
  102.                     break;
  103.                 }
  104.                 case BUGREPORT: {
  105.                     /* put the bug report form into the scrap and alert the user */
  106.                     if (mfpresent)
  107.                         /* make sure mf updates all client's scrap info */
  108.                         SystemEdit(EDCOPY - 1);
  109.         
  110.                     ZeroScrap();
  111.                     PutScrap((long) strlen(bugreport), 'TEXT', bugreport);
  112.                     fillwindow(COPYWINDOW, bugnote, (long) strlen(bugnote), geneva, 12, (long) 0);
  113.                     break;
  114.                 }
  115. #ifdef USEHELPWINDOW
  116.                 case COMET_HELP: {
  117.                     selectwindow(helpwindow);
  118.                     break;
  119.                 }
  120. #endif
  121.                 case SKIPAPPLE: {
  122.                     break;
  123.                 }
  124.                 default: {
  125.                     GrafPtr saveport;
  126.                     
  127.                     GetPort(&saveport);
  128.                     GetItem(menu[APPLEMENU], theItem, name);
  129.                     
  130.                     emwdeactivate();
  131.                     if (keydp->edit && keydp->textscrapped) {
  132.                         /* convert the TE scrap if it's the top window */
  133.                         HLock(TEScrHandle);
  134.                         tetoscrap(*TEScrHandle, TEScrLen);
  135.                         HUnlock(TEScrHandle);
  136.                     }
  137.                     darefnum = OpenDeskAcc(name);
  138.                     SetPort(saveport);
  139.                     if (!mfpresent && darefnum) {
  140.                         setscript(0L);        /* restore regular script */
  141.                         emedit(keydp, FALSE);
  142.                         DrawMenuBar();
  143.                     }
  144.                     break;
  145.                 }
  146.             }
  147.             break;
  148.         }
  149.         case filemenu: {
  150.             menufile(theItem);
  151.             break;
  152.         }
  153.         case editmenu: {
  154.             /* just serve DA's */
  155.             if (SystemEdit(theItem - 1))
  156.                 break;
  157.             else {
  158.                 menuedit(theItem);
  159.             }
  160.             break;
  161.         }
  162.         case netmenu: {
  163.             menunetwork(theItem);
  164.             break;
  165.         }
  166.         case serialmenu: {
  167.             menuserial(theItem);
  168.             break;
  169.         }
  170.         case sendmenu: {
  171.             menusend(theItem);
  172.             break;
  173.         }
  174. #ifdef USESERSEND
  175.         case serialsendmenu: {
  176.             menusersend(theItem);
  177.             break;
  178.         }
  179. #endif
  180.         case ctrlmenu: {
  181.             menuctrl(theItem);
  182.             break;
  183.         }
  184.         case windmenu: {
  185.             menuwind(theItem);
  186.             break;
  187.         }
  188.         case fsizemenu: {
  189.             /* change font size */
  190.             GetItem(menu[FSIZEMENU], theItem, name);
  191.             ptoc(name);
  192.             if (keydp == emdp)
  193.                 /* guarantee keydp struct updated, we may setcontext() */
  194.                 savecontext(emdp);
  195.             else
  196.                 getcontext(keydp);
  197.                 
  198.             setscreensize(atoi(name));
  199.             setfontsizemenu(emdp->fontsize);
  200.             
  201.             setcontext(emdp);
  202.             break;
  203.         }
  204.         case curkeymenu: {
  205.             menucurkey(theItem);
  206.             break;
  207.         }
  208.         case pfkeymenu: {
  209.             menupfkey(theItem);
  210.             break;
  211.         }
  212.         case asc1keymenu: {
  213.             keymap( (char) 0, (char) ((theItem - 3) & 0x1f), 0);
  214.                 /* allow -1 for 1-n numbering, -2 for title in #1 slot & bar */
  215.             break;
  216.         }
  217.         case asc2keymenu: {
  218.             if (theItem == ASCMENUDEL)
  219.                 keymap((char) 0,  (char) (0x7f), 0);
  220.             else
  221.                 keymap((char) 0, (char) ( ( theItem + 13) & 0x1f), 0);
  222.                 /* allow -1 for 1-n numbering, -2 for title in #1 slot & bar */
  223.             break;
  224.         }
  225.         case helpmenu: {
  226.             int tfont;
  227.             int tsize;
  228.             
  229.             if (keydp != NULL) {
  230.                 tfont = keydp->normfont;
  231.                 tsize = keydp->fontsize;
  232.             }
  233.             else {
  234.                 tfont = FONTCUA;
  235.                 tsize = 9;
  236.             }
  237.             
  238.             switch (theItem) {
  239.                 case INFOBACK: {
  240.                     helpwindow(ITEXTBACK, tfont, tsize);
  241.                     break;
  242.                 }
  243.                 case INFOABOUTASCII: {
  244.                     helpwindow(ITEXTABOUTASCII, tfont, tsize);
  245.                     break;
  246.                 }
  247.                 case INFOABOUTIBM: {
  248.                     helpwindow(ITEXTABOUTIBM, tfont, tsize);
  249.                     break;
  250.                 }
  251.                 case INFOMACROS: {
  252.                     helpwindow(ITEXTMACROS, tfont, tsize);
  253.                     break;
  254.                 }
  255.                 case INFOFILE: {
  256.                     helpwindow(ITEXTFILE, tfont, tsize);
  257.                     break;
  258.                 }
  259.                 case INFOEDIT: {
  260.                     helpwindow(ITEXTEDIT, tfont, tsize);
  261.                     break;
  262.                 }
  263.                 case INFOWIND: {
  264.                     helpwindow(ITEXTWIND, tfont, tsize);
  265.                     break;
  266.                 }
  267.                 case INFOTN: {
  268.                     helpwindow(ITEXTTN, tfont, tsize);
  269.                     break;
  270.                 }
  271.                 case INFOSERIAL: {
  272.                     helpwindow(ITEXTSERIAL, tfont, tsize);
  273.                     break;
  274.                 }
  275.                 case INFOCONTROL: {
  276.                     helpwindow(ITEXTCONTROL, tfont, tsize);
  277.                     break;
  278.                 }
  279.                 case INFOASCII: {
  280.                     helpwindow(ITEXTASCII, tfont, tsize);
  281.                     break;
  282.                 }
  283.                 case INFOIBM: {
  284.                     helpwindow(ITEXTIBM, tfont, tsize);
  285.                     break;
  286.                 }
  287.                 case DUMPINFO: {
  288.                     if (keydp != NULL && keydp->textwindow != NULL) {
  289.                         /* dump all the help into a text window */
  290.                         helptextwindow(TEXTABOUT);
  291.                         helptextwindow(ITEXTBACK);
  292.                         helptextwindow(TEXTLOGON);
  293.                         helptextwindow(ITEXTABOUTASCII);
  294.                         helptextwindow(ITEXTABOUTIBM);
  295.                         helptextwindow(ITEXTMACROS);
  296.                     }
  297.                     break;
  298.                 }
  299.                 case DUMPINFO2: {
  300.                     if (keydp != NULL && keydp->textwindow != NULL) {
  301.                         /* dump all the help into a text window */
  302.                         helptextwindow(ITEXTFILE);
  303.                         helptextwindow(ITEXTEDIT);
  304.                         helptextwindow(ITEXTWIND);
  305.                         helptextwindow(ITEXTTN);
  306.                         helptextwindow(ITEXTSERIAL);
  307.                         helptextwindow(ITEXTCONTROL);
  308.                         helptextwindow(TEXTGLOBALDLOG);
  309.                         helptextwindow(TEXTWINDDLOG);                        
  310.                         helptextwindow(TEXTEMDLOG);                        
  311.                         helptextwindow(TEXT3270DLOG);                        
  312.                         helptextwindow(ITEXTASCII);
  313.                         helptextwindow(ITEXTIBM);
  314.                             /* add the dialog help also... */
  315.                         
  316.                     }
  317.                     break;
  318.                 }
  319.             }
  320.             break;
  321.         }
  322.     }
  323.     if (!autokeycommand)
  324.         HiliteMenu(0);
  325. }
  326.  
  327.  
  328.  
  329. setupapplemenu()
  330. {
  331.     InitMenus();
  332.  
  333.     menu[APPLEMENU] = NewMenu(applemenu, "\P\024");
  334.     AppendMenu(menu[APPLEMENU], "\PAbout Comet…");
  335.     AppendMenu(menu[APPLEMENU], "\PBug Report");
  336. #ifdef USEHELPWINDOW
  337.     AppendMenu(menu[APPLEMENU], "\PHelp…");
  338. #endif
  339.     AppendMenu(menu[APPLEMENU], "\P(-");
  340.     AddResMenu(menu[APPLEMENU], 'DRVR');
  341. }
  342.  
  343.  
  344. setupmenu()
  345. {
  346.     int count;
  347.  
  348.     menu[FILEMENU] = NewMenu(filemenu, "\PFile");
  349.     
  350.     AppendMenu(menu[FILEMENU], "\PNew…/N");
  351.     AppendMenu(menu[FILEMENU], "\POpen…/O");
  352.     AppendMenu(menu[FILEMENU], "\PClose");
  353.     AppendMenu(menu[FILEMENU], "\PSave Configuration…");
  354.     AppendMenu(menu[FILEMENU], "\P(-");
  355.     AppendMenu(menu[FILEMENU], "\PType file name at cursor…");
  356.     AppendMenu(menu[FILEMENU], "\P(-");
  357.     AppendMenu(menu[FILEMENU], "\PSave screen as…");
  358.     AppendMenu(menu[FILEMENU], "\PAppend screen to…");
  359.     AppendMenu(menu[FILEMENU], "\PSave screen…");
  360.     AppendMenu(menu[FILEMENU], "\PAppend screen…/S");
  361.     AppendMenu(menu[FILEMENU], "\POpen Log…");
  362.     AppendMenu(menu[FILEMENU], "\PLog session in ");
  363.     AppendMenu(menu[FILEMENU], "\P(-");
  364.     AppendMenu(menu[FILEMENU], "\PPage Layout…");
  365.     AppendMenu(menu[FILEMENU], "\PPrint…/P");
  366.     AppendMenu(menu[FILEMENU], "\P(-");
  367.     AppendMenu(menu[FILEMENU], "\PQuit/Q");
  368.  
  369.     menu[EDITMENU] = NewMenu(editmenu, "\PEdit");
  370.     
  371.     AppendMenu(menu[EDITMENU], "\P(Undo/Z");
  372.     AppendMenu(menu[EDITMENU], "\P(-");
  373.     AppendMenu(menu[EDITMENU], "\PCut/X");
  374.     AppendMenu(menu[EDITMENU], "\PCopy/C");
  375.     AppendMenu(menu[EDITMENU], "\PPaste/V");
  376.     AppendMenu(menu[EDITMENU], "\P(Clear");
  377.     AppendMenu(menu[EDITMENU], "\PSelect All/A");
  378.     AppendMenu(menu[EDITMENU], "\PTable Mode for Copy and Save/T");
  379.  
  380. #ifdef USETEXTWINDOWS
  381.     AppendMenu(menu[EDITMENU], "\P(-");
  382.     AppendMenu(menu[EDITMENU], "\PAppend file to .edit window…");
  383.     AppendMenu(menu[EDITMENU], "\PAppend screen to .edit window/B");
  384.     AppendMenu(menu[EDITMENU], "\PRecord session/'");
  385.     AppendMenu(menu[EDITMENU], "\PPage up/[");
  386.     AppendMenu(menu[EDITMENU], "\PPage down/]");
  387.     AppendMenu(menu[EDITMENU], "\PJump to end/;");
  388. #ifdef USETEXTWINDFIND
  389.     AppendMenu(menu[EDITMENU], "\PFind…/F");
  390.     AppendMenu(menu[EDITMENU], "\PFind same/G");
  391. #endif
  392.     AppendMenu(menu[EDITMENU], "\PAdd Returns");
  393.     AppendMenu(menu[EDITMENU], "\PRemove Returns");
  394. #else
  395.     AppendMenu(menu[EDITMENU], "\P(-");
  396.     AppendMenu(menu[EDITMENU], "\PAppend screen to Clipboard/B");
  397.     AppendMenu(menu[EDITMENU], "\PLog session");
  398. #endif
  399.  
  400.     menu[WINDMENU] = NewMenu(windmenu, "\PWindow");
  401.     AppendMenu(menu[WINDMENU], "\PClose session/W");
  402.     AppendMenu(menu[WINDMENU], "\P(Re-open session/R");
  403.     AppendMenu(menu[WINDMENU], "\PReconfigure session…");
  404. #ifdef USETEXTWINDOWS
  405.     AppendMenu(menu[WINDMENU], "\PToggle .edit window/E");
  406. #else
  407.     AppendMenu(menu[WINDMENU], "\P(Toggle .edit window/E");
  408. #endif
  409.     AppendMenu(menu[WINDMENU], "\P(-");
  410.  
  411.     menu[NETWORKMENU] = NewMenu(netmenu, "\PTelnet");
  412.     
  413.     AppendMenu(menu[NETWORKMENU], "\PType my address at cursor");
  414.     AppendMenu(menu[NETWORKMENU], "\PSend");
  415.     AppendMenu(menu[NETWORKMENU], "\PShow statistics…");
  416.     AppendMenu(menu[NETWORKMENU], "\PSend after Return");
  417.     AppendMenu(menu[NETWORKMENU], "\PLocal echo");
  418.     AppendMenu(menu[NETWORKMENU], "\P(-");
  419.     {
  420.         AppendMenu(menu[NETWORKMENU], "\P ");    /* MYADDR */
  421.         AppendMenu(menu[NETWORKMENU], "\P ");    /* HOSTNAME */
  422.         AppendMenu(menu[NETWORKMENU], "\P ");    /* HOSTADDR */
  423.         /* 1st, 2nd and 3rd are placeholders for my address & host name/address */
  424.     }
  425.     
  426.     makecontrolmenu("\PControl");
  427.     
  428.     menu[PFKEYMENU] = GetMenu(pfkeymenu);
  429.     menu[CURKEYMENU] = GetMenu(curkeymenu);
  430.         /* we get these because 1) they're complex 2) users need to modify curkey */
  431.  
  432.     menu[HELPMENU] = NewMenu(helpmenu, "\PInfo");
  433.     AppendMenu(menu[HELPMENU], "\PBackground…");
  434.     AppendMenu(menu[HELPMENU], "\PASCII…");
  435.     AppendMenu(menu[HELPMENU], "\PIBM…");
  436.     AppendMenu(menu[HELPMENU], "\PMacros…");
  437.     AppendMenu(menu[HELPMENU], "\PFile menu…");
  438.     AppendMenu(menu[HELPMENU], "\PEdit menu…");
  439.     AppendMenu(menu[HELPMENU], "\PWindow menu…");
  440.     AppendMenu(menu[HELPMENU], "\PTelnet menu…");
  441.     AppendMenu(menu[HELPMENU], "\PSerial menu…");
  442.     AppendMenu(menu[HELPMENU], "\PControl menu…");
  443.     AppendMenu(menu[HELPMENU], "\PASCII menu…");
  444.     AppendMenu(menu[HELPMENU], "\PIBM PF menu…");
  445.     AppendMenu(menu[HELPMENU], "\P(-");
  446.     AppendMenu(menu[HELPMENU], "\P(Click to return");
  447. #ifdef USETEXTWINDOWS
  448.     AppendMenu(menu[HELPMENU], "\P(-");
  449.     AppendMenu(menu[HELPMENU], "\PDump Overview into .edit window");
  450.     AppendMenu(menu[HELPMENU], "\PDump Menu Info into .edit window");
  451. #endif
  452.  
  453.     /* add the ASCII menus ... */
  454.     menu[ASC1KEYMENU] = NewMenu(asc1keymenu, "\PASCII");
  455.     AppendMenu(menu[ASC1KEYMENU], "\PName    Option-…");
  456.     AppendMenu(menu[ASC1KEYMENU], "\P(-");
  457.     AppendMenu(menu[ASC1KEYMENU], "\PNUL                     @");
  458.     AppendMenu(menu[ASC1KEYMENU], "\PSOH                      A");
  459.     AppendMenu(menu[ASC1KEYMENU], "\PSTX                      B");
  460.     AppendMenu(menu[ASC1KEYMENU], "\PETX                      C");
  461.     AppendMenu(menu[ASC1KEYMENU], "\PEnd-of-Trans      D");
  462.     AppendMenu(menu[ASC1KEYMENU], "\PENO                      E");
  463.     AppendMenu(menu[ASC1KEYMENU], "\PACK                      F");
  464.     AppendMenu(menu[ASC1KEYMENU], "\PBell                      G");
  465.     AppendMenu(menu[ASC1KEYMENU], "\PBackspace          H");
  466.     AppendMenu(menu[ASC1KEYMENU], "\PTab                      I");
  467.     AppendMenu(menu[ASC1KEYMENU], "\PLineFeed             J");
  468.     AppendMenu(menu[ASC1KEYMENU], "\PVertical Tab        K");
  469.     AppendMenu(menu[ASC1KEYMENU], "\PForm Feed           L");
  470.     AppendMenu(menu[ASC1KEYMENU], "\PReturn                M");
  471.     AppendMenu(menu[ASC1KEYMENU], "\PSO                        N");
  472.     AppendMenu(menu[ASC1KEYMENU], "\PSI                         O");
  473.     
  474.     menu[ASC2KEYMENU] = NewMenu(asc2keymenu, "\PASCII");
  475.     AppendMenu(menu[ASC2KEYMENU], "\PName   Option-…");
  476.     AppendMenu(menu[ASC2KEYMENU], "\P(-");
  477.     AppendMenu(menu[ASC2KEYMENU], "\PDLE                      P");
  478.     AppendMenu(menu[ASC2KEYMENU], "\PXON                     Q");
  479.     AppendMenu(menu[ASC2KEYMENU], "\PDC2                     R");
  480.     AppendMenu(menu[ASC2KEYMENU], "\PXOFF                    S");
  481.     AppendMenu(menu[ASC2KEYMENU], "\PDC4                     T");
  482.     AppendMenu(menu[ASC2KEYMENU], "\PNAK                    U");
  483.     AppendMenu(menu[ASC2KEYMENU], "\PSYN                     V");
  484.     AppendMenu(menu[ASC2KEYMENU], "\PETB                     W");
  485.     AppendMenu(menu[ASC2KEYMENU], "\PCAN                     X");
  486.     AppendMenu(menu[ASC2KEYMENU], "\PEM                       Y");
  487.     AppendMenu(menu[ASC2KEYMENU], "\PSUB                      Z");
  488.     AppendMenu(menu[ASC2KEYMENU], "\PEscape                 [");
  489.     AppendMenu(menu[ASC2KEYMENU], "\PFS                        \\");
  490.     AppendMenu(menu[ASC2KEYMENU], "\PGS                        ]");
  491.     AppendMenu(menu[ASC2KEYMENU], "\PRS                        6");
  492.     AppendMenu(menu[ASC2KEYMENU], "\PUS                        _");
  493.     AppendMenu(menu[ASC2KEYMENU], "\PDelete is Backspace");
  494.  
  495.     for (count = 0; count < NIBMMENUS; count++)
  496.         InsertMenu(menu[count], 0);
  497.  
  498.     menu[SERIALMENU] = NewMenu(serialmenu, "\PSerial");
  499.         AppendMenu(menu[SERIALMENU], "\PSytek Escape");
  500.         AppendMenu(menu[SERIALMENU], "\PHang up on Close");
  501.         AppendMenu(menu[SERIALMENU], "\P<UBaud Rate");
  502.         AppendMenu(menu[SERIALMENU], "\P   57600");
  503.         AppendMenu(menu[SERIALMENU], "\P   38400");
  504.         AppendMenu(menu[SERIALMENU], "\P   19200");
  505.         AppendMenu(menu[SERIALMENU], "\P     9600");
  506.         AppendMenu(menu[SERIALMENU], "\P     4800");
  507.         AppendMenu(menu[SERIALMENU], "\P     2400");
  508.         AppendMenu(menu[SERIALMENU], "\P     1200");
  509.         AppendMenu(menu[SERIALMENU], "\P       300");
  510.         AppendMenu(menu[SERIALMENU], "\P<UData Bits");
  511.         AppendMenu(menu[SERIALMENU], "\P           8");
  512.         AppendMenu(menu[SERIALMENU], "\P           7");
  513.         AppendMenu(menu[SERIALMENU], "\P           6");
  514.         AppendMenu(menu[SERIALMENU], "\P<UParity Bits");
  515.         AppendMenu(menu[SERIALMENU], "\P     None");
  516.         AppendMenu(menu[SERIALMENU], "\P      Even");
  517.         AppendMenu(menu[SERIALMENU], "\P       Odd");
  518.         AppendMenu(menu[SERIALMENU], "\P<UStop Bits");
  519.         AppendMenu(menu[SERIALMENU], "\P         2");
  520.         AppendMenu(menu[SERIALMENU], "\P         1.5");
  521.         AppendMenu(menu[SERIALMENU], "\P         1");
  522.         AppendMenu(menu[SERIALMENU], "\P(-");
  523.         AppendMenu(menu[SERIALMENU], "\PHang up phone");
  524.         AppendMenu(menu[SERIALMENU], "\PReset Parameter RAM");
  525.  
  526.     /* make the hierarchical menus */
  527.     
  528.     /* font sizes */
  529.     if (environs.systemVersion) {
  530.         /* skip hierarchical menus if not up to Vol 5 */
  531.         /* make the Size menu */
  532.         
  533.         menu[FSIZEMENU] = NewMenu(fsizemenu, "\P");
  534.         AppendMenu(menu[FSIZEMENU], "\P9;12;16");    /* FONTSIZECOUNT = 3 */
  535.         InsertMenu(menu[FSIZEMENU], -1);
  536.         SetItemCmd(menu[CTRLMENU], MFONTSIZE, (char) 0x1B);            
  537.             /* indicate hierarchical */
  538.         SetItemMark(menu[CTRLMENU], MFONTSIZE, (char) fsizemenu);
  539.             /* attach font size menu */
  540.  
  541.         /* make the Telnet Send menu */
  542.         menu[SENDMENU] = NewMenu(sendmenu, "\P");
  543.         
  544.         AppendMenu(menu[SENDMENU], "\PErase character");
  545.         AppendMenu(menu[SENDMENU], "\PErase line");
  546.         AppendMenu(menu[SENDMENU], "\PAre you there");
  547.         AppendMenu(menu[SENDMENU], "\PInterrupt process");
  548.         AppendMenu(menu[SENDMENU], "\PAbort output");
  549.         AppendMenu(menu[SENDMENU], "\PBreak");
  550.     
  551.         SetItemCmd(menu[NETWORKMENU], SENDHIER, (char) 0x1B);            
  552.             /* indicate hierarchical */
  553.         SetItemMark(menu[NETWORKMENU], SENDHIER, (char) sendmenu);
  554.             /* attach send menu */
  555.  
  556. #ifdef USESERSEND
  557.         /* make the Serial Send menu */
  558.         menu[SERSENDMENU] = NewMenu(serialsendmenu, "\P");
  559.         
  560.         AppendMenu(menu[SERSENDMENU], "\PSytek Escape");
  561.         AppendMenu(menu[SERSENDMENU], "\PAlt. Sytek Escape");
  562.     
  563.         SetItemCmd(menu[SERIALMENU], SERSENDHIER, (char) 0x1B);            
  564.             /* indicate hierarchical */
  565.         SetItemMark(menu[SERIALMENU], SERSENDHIER, (char) serialsendmenu);
  566.             /* attach serial send menu */
  567. #endif
  568.     }
  569.     else {
  570.         DisableItem(menu[CTRLMENU], MFONTSIZE);
  571.         DisableItem(menu[NETWORKMENU], SENDHIER);
  572. #ifdef USESERSEND
  573.         DisableItem(menu[SERIALMENU], SERSENDHIER);
  574. #endif
  575.     }
  576.  
  577.     if (!environs.hasColorQD) {
  578.         /* turn off if color not present */
  579.         DisableItem(menu[CTRLMENU], MSETCOLOR);
  580.     }
  581.     DrawMenuBar();
  582. }
  583.  
  584.  
  585. /* 
  586.     fix the menu to show the current connection control menu 
  587.     serial, network or conn mgr; return TRUE if menu bar
  588.     needs to be drawn.
  589. */
  590.  
  591. setmenuconn(twp)
  592. struct winds * twp;
  593. {
  594.     static int oconntype = -1;
  595.     static int oconnmenu1 = 0;
  596.     static int oconnmenu2 = 0;
  597.     int retval = FALSE;
  598.     
  599. #ifdef SOMEHOW        
  600.     /* make the window name the title on the Control menu */
  601.     DeleteMenu(ctrlMenu);
  602.     HLock(keydp->hhostname);
  603.     makecontrolmenu(*keydp->hhostname);
  604.     HUnlock(keydp->hhostname);
  605.     InsertMenu(menu[CTRLMENU], netmenu);
  606. #endif
  607.  
  608.     if (oconntype == twp->conntype) {
  609.         /* already set OK, never the first time */
  610.         if (twp->conntype == CONN_MACTCP
  611.                 || twp->conntype == CONN_CUTCP) {
  612.  
  613.             /* put the host/window name into the menu */
  614.             setmenuaddresses(twp->hhostname, &twp->fhost);
  615.         }
  616.     
  617.         return(FALSE);
  618.     }
  619.  
  620.     if (oconnmenu1) {
  621.         DeleteMenu(oconnmenu1);
  622.         oconnmenu1 = 0;
  623.         retval = TRUE;
  624.     }
  625.     if (oconnmenu2) {
  626.         DeleteMenu(oconnmenu2);
  627.         oconnmenu2 = 0;
  628.         retval = TRUE;
  629.     }
  630.     switch (twp->conntype) {
  631.         case CONN_CUTCP:
  632.         case CONN_MACTCP: {
  633.             InsertMenu(menu[NETWORKMENU], ctrlmenu);
  634.             InsertMenu(menu[SENDMENU], -1);
  635.             setmenuaddresses(twp->hhostname, &twp->fhost);
  636.             oconntype = twp->conntype;
  637.             oconnmenu1 = netmenu;
  638.             oconnmenu2 = sendmenu;
  639.             retval = TRUE;
  640.             break;
  641.         }
  642.         case CONN_SERD: {
  643.             InsertMenu(menu[SERIALMENU], ctrlmenu);
  644. #ifdef USESERSEND
  645.             InsertMenu(menu[SERSENDMENU], -1);
  646. #endif
  647.             oconntype = CONN_SERD;
  648.             oconnmenu1 = serialmenu;
  649.             oconnmenu2 = 0;
  650.             retval = TRUE;
  651.             break;
  652.         }
  653.         case CONN_COMMMGR: {
  654.             break;
  655.         }
  656.     }
  657.     return(retval);
  658. }
  659.  
  660.  
  661. /* fix the menu to accord with the current settings */
  662.  
  663. menucheck(twp)
  664. struct winds * twp;
  665. {
  666.     int keymchange;
  667.     int setmchange;
  668.     int setconnchange;
  669.     
  670.     CheckItem(menu[FILEMENU], FILESESSION, twp->filesession ? TRUE : FALSE); 
  671.     CheckItem(menu[EDITMENU], LOGSESSION, twp->logsession ? TRUE : FALSE); 
  672.     CheckItem(menu[CTRLMENU], KEYXON, twp->dokeymacros ? TRUE : FALSE); 
  673.  
  674.     setsendm(twp->ucb.u_sendm);
  675.     setmenureturn(twp);
  676.     setmecho(twp->ucb.u_echom);
  677.  
  678.     pfmenuhack(twp);                        /* IBM menu PF keys */
  679.     selmenuitems(twp);                            /* selection/screen */
  680.     setfontsizemenu(twp->fontsize);        /* font size */
  681.  
  682.     keymchange = keymenus(twp);
  683.     setmchange = setmsession(twp);
  684.     setconnchange = setmenuconn(twp);
  685.  
  686.     if (keymchange || setmchange || setconnchange)
  687.         return(TRUE);
  688.     else
  689.         return(FALSE);
  690. }
  691.  
  692.  
  693. /* ignore all files that were not created by this program */
  694.  
  695. pascal Boolean
  696. SFgetfilter(finfopb)
  697. ParmBlkPtr finfopb;
  698. {
  699. #ifdef USETASK
  700.     if (tk_cur != NULL) {
  701.         /* if tasking is on, do a yield to avoid timeout */
  702.         bkrd_service();
  703.     }
  704. #endif
  705.  
  706.     if (finfopb->u.fp.ioFlFndrInfo.fdCreator == '3278')
  707.         /* FALSE means *show* */
  708.         return((Boolean) FALSE);
  709.     else
  710.         return((Boolean) TRUE);
  711. }
  712.  
  713.  
  714. /* examine all files */
  715.  
  716. pascal Boolean
  717. SFnofilter(finfopb)
  718. ParmBlkPtr finfopb;
  719. {
  720. #ifdef USETASK
  721.     if (tk_cur != NULL) {
  722.         /* if tasking is on, do a yield to avoid timeout */
  723.         bkrd_service();
  724.     }
  725. #endif
  726.  
  727.     return((Boolean) FALSE);
  728. }
  729.  
  730.  
  731.  
  732. /* handle File menu items */
  733.  
  734. menufile(theitem)
  735. short theitem;
  736. {
  737.     switch (theitem) {
  738.         case NEWCONN: {
  739.             newconn();
  740.             break;
  741.         }
  742.         case OPENCONN: {
  743.             Point here;
  744.             SFReply openreply;
  745.             SFTypeList typelist;
  746.             
  747.             getcontext(keydp);
  748.  
  749.             if (chkbackground())
  750.                 break;
  751.                 
  752.             openreply.good = FALSE;
  753.             emwdeactivate();
  754.             
  755.             here.v = 60;
  756.             here.h = 100;
  757.             centerpoint(&here);
  758.             
  759.             typelist[0] = 'TEXT';
  760.             modaldialog = TRUE;
  761.             
  762.             SFGetFile(pass(here), "\POpen Session Document", 
  763.                  (ProcPtr) SFgetfilter, 1, &typelist, (ProcPtr) NULL, &openreply);
  764.                  
  765.             modaldialog = FALSE;
  766.             if (openreply.good) {
  767.                 /* stick name in at cursor position */
  768.                 char * chp;
  769.                 char * endp;
  770.                 char * destp;
  771.                 struct token atoke;
  772.                 short newresfid;
  773.                 
  774.                 SetVol((StringPtr) NULL, openreply.vRefNum);
  775.                 if ((newresfid = myopenresfile(&openreply.fName, (short) openreply.vRefNum, (Byte) fsRdWrPerm)) == -1) {
  776.                     /* can't open file, give up */
  777.                     error("Can't open the document");
  778.                     break;
  779.                 }
  780.                 /* we got a file, make a connection */
  781.  
  782.                 if (makeconn()) {
  783.                     closeconfig(emdp);
  784.                     error("Not enough memory for new session");
  785.                     break;
  786.                 }
  787.                 /* emdp is now points to a new blank connection record */
  788.                 
  789.                 /* copy the file ids */
  790.                 
  791.                 emdp->resfid = newresfid;
  792. #ifdef MFOPENWORKS
  793.                 /* SFSaveDisk & CurDirStore don't seem to be set on MF doc
  794.                     launches... */
  795.                 emdp->resvref = openreply.vRefNum;
  796.                 emdp->resvol = -(*SFSaveDisk); 
  797.                 emdp->resdir = *CurDirStore;
  798.  
  799.                 emdp->downvref = openreply.vRefNum;
  800.                 emdp->downvol = -(*SFSaveDisk); 
  801.                 emdp->downdir = *CurDirStore;
  802. #else
  803.                 setemdpresvol();
  804. #endif
  805.                 /* copy the name & other info into the appfile struct */
  806.                 chp = &openreply.fName[0];
  807.                 endp = chp + openreply.fName[0] + 1;
  808.                 destp = &emdp->appfile.fName;
  809.                 
  810.                 while (chp < endp) {
  811.                     *destp++ = *chp++;
  812.                 }
  813.  
  814.                 getconfig();
  815.                 
  816.                 PtrToHand(&emdp->appfile.fName, &emdp->hhostname,
  817.                     (long) (emdp->appfile.fName.length + 1));
  818.                     /* save name as pascal string in emdp->hhostname */
  819.  
  820.                 if (optkeydown()) {
  821.                     /* give user the opportunity to revise the configuration */
  822.                     if (namewindow()) {
  823.                         /* continue if Cancelled */
  824.                         ;
  825.                     }
  826.                 }
  827.                 if (emdp->conntype == CONN_MACTCP
  828.                         || emdp->conntype == CONN_CUTCP) {
  829.                     /* on startup, get the null-terminated c string from the resource file */
  830.                     if (emdp->hlasthost != NULL) {
  831.                         HLock(emdp->hlasthost);
  832.                         if (resolve_name(*emdp->hlasthost, &emdp->fhost)) {
  833.                             HUnlock(emdp->hlasthost);
  834.                             if (namewindow()) {
  835.                                 /* give the user a chance to fix things */
  836.                                 closeconfig(emdp);        /* close after getting resources */
  837.                                 killconn();
  838.                                 break;
  839.                             }
  840.                         }
  841.                         HUnlock(emdp->hlasthost);
  842.                     }
  843.                     else {
  844.                         if (namewindow()) {
  845.                             /* bad address, give the user a chance to fix things */
  846.                             closeconfig(emdp);        /* close after getting resources */
  847.                             killconn();
  848.                             break;
  849.                         }
  850.                     }
  851.                 }
  852.                 if (makewind()) {
  853.                     /* out of memory */
  854.                     closeconfig(emdp);
  855.                     killconn();
  856.                     break;
  857.                 }
  858.                 keyxinit();
  859.  
  860.                 addwindmenu(emwindow);
  861.  
  862.                 closeconfig(emdp);        /* close after getting resources */
  863.  
  864.                 openconn(emdp);
  865.             }
  866.             break;
  867.         }
  868.         case WMCLOSEWIND: {
  869.             getcontext(keydp);
  870.             if (keydp->connopen) {
  871.                 if (querycloseconn(keydp))
  872.                     /* user doesn't want to end session */
  873.                     return();
  874.     
  875.                 closeconn(keydp);
  876.                 if (keydp->disposeonclose) {
  877.                     /* better not do queryclosewind() AGAIN */
  878.                     return();
  879.                 }
  880.                 else {
  881.                     /* wait to kill window until truly closed */
  882.                     while (emdp->connopen)
  883.                         bkrd_service();
  884.                 }
  885.             }
  886.             queryclosewind(emdp);
  887.             return();
  888.         }
  889.         case FILENAME: {
  890.             /* type a filename from GetFile into the 3270 screen */
  891.             Point here;
  892.             SFReply sftypereply;
  893.             SFTypeList typelist;
  894.             
  895.             if (chkbackground())
  896.                 break;
  897.                 
  898.             sftypereply.good = FALSE;
  899.             emwdeactivate();
  900.             
  901.             here.v = 60;
  902.             here.h = 100;
  903.             centerpoint(&here);
  904.             
  905.             typelist[0] = 'TEXT';
  906.             
  907.             getcontext(keydp);
  908.             modaldialog = TRUE;
  909.  
  910.             *SFSaveDisk = - emdp->downvol;
  911.             *CurDirStore = emdp->downdir;
  912.         
  913.             /* TODO kevin should have application name if not launched from document */
  914.             SFGetFile(pass(here), "\PType file name at cursor", 
  915.                  (ProcPtr) SFnofilter, 1, &typelist, (ProcPtr) NULL, &sftypereply);
  916.  
  917.             modaldialog = FALSE;
  918.             if (sftypereply.good) {
  919.                 /* stick name in at cursor position */
  920.                 char * chp;
  921.                 char * endp;
  922.                 struct token atoke;
  923.                 WDPBRec WDPB;    
  924.                 
  925.                 SetVol((StringPtr) NULL, sftypereply.vRefNum);
  926.                 emdp->downvref = sftypereply.vRefNum;
  927.  
  928.                 WDPB.ioCompletion = NULL;
  929.                 WDPB.ioNamePtr = NULL;
  930.                 PBHGetVol(&WDPB, (Boolean) FALSE);    
  931.                 emdp->downvol = WDPB.ioWDVRefNum;
  932.                 emdp->downdir = WDPB.ioWDDirID;
  933.                     /* save for the next SFget dialog */
  934.  
  935.                 pastemode = 1;
  936.                 chp = &sftypereply.fName[1];
  937.                 endp = chp + sftypereply.fName[0];
  938.                 
  939.                 atoke.class = RSLT_ASCI;
  940.                 while (chp < endp) {
  941.                     atoke.entry = *chp++;
  942.                     keyputaction(RSLT_ASCI, atoke.entry);
  943.                 }
  944.                 pastemode = 0;
  945.             }
  946.             break;
  947.         }
  948.         case APPENDSCREEN: {
  949.             getcontext(keydp);
  950.             savetext(RF_APPEND);
  951.             break;
  952.         }
  953.         case SAVESCREEN: {
  954.             getcontext(keydp);
  955.             savetext(RF_SAVE);
  956.             break;
  957.         }
  958.         case APPENDSCREENTO: {
  959.             getcontext(keydp);
  960.             savetext(RF_APPENDTO);
  961.             break;
  962.         }
  963.         case SAVESCREENAS: {
  964.             getcontext(keydp);
  965.             savetext(RF_SAVEAS);
  966.             break;
  967.         }
  968.         case LOGOPEN: {
  969.             getcontext(keydp);
  970.             if (logopen()) {
  971.                 /* turn logging on automatically... */
  972.                 keydp->filesession = TRUE;
  973.                 keydp->confchanged = TRUE;
  974.                 CheckItem(menu[FILEMENU], FILESESSION, keydp->filesession ? TRUE : FALSE);
  975.             }
  976.             break;
  977.         }
  978.         case FILESESSION: {
  979.             keydp->filesession = !keydp->filesession;
  980.             keydp->confchanged = TRUE;
  981.             CheckItem(menu[FILEMENU], FILESESSION, keydp->filesession ? TRUE : FALSE);
  982.             break;
  983.         }
  984.         case PRINTQD: {
  985.             getcontext(keydp);
  986. #ifdef DOQDPRINT
  987.             QDprinttext(keydp->edit ? RF_PRINTTEXT : RF_PRINTSCREEN, TRUE);
  988.                 /* print with a dialog */
  989. #else
  990.             printtext(RF_PRINTSCRAP);
  991. #endif
  992.  
  993.             break;
  994.         }
  995. #ifdef USEDRAFT
  996.         case PRINTSCREEN: {
  997.             getcontext(keydp);
  998.             printtext(RF_PRINTSCREEN);
  999.             break;
  1000.         }
  1001. #endif
  1002. #ifdef DOQDPRINT
  1003.         case PRINTLAYOUT: {
  1004.             /* doing the print style dialog... */
  1005.             extern THPrint hprec;
  1006.             
  1007.             getcontext(keydp);
  1008.             if (hprec == NULL) {
  1009.                 hprec = NewHandle((long) sizeof(TPrint));
  1010.                 PrintDefault(hprec);
  1011.                 if (hprec == NULL)
  1012.                     return(-1);
  1013.             }
  1014.             PrOpen();
  1015.             if (PrError()) {
  1016.                 error("Can't open Printer Driver");
  1017.                 break;
  1018.             }
  1019.             PrStlDialog(hprec);
  1020.             PrClose();
  1021.             break;
  1022.         }
  1023. #endif
  1024.         case SAVECONF: {
  1025.             /* save the current window's configuration in a document file */
  1026.             getcontext(keydp);
  1027.             if (optkeydown()) {
  1028.                 namewindow();
  1029.             }
  1030.             saveconfig(keydp, creator);
  1031.             
  1032.             break;
  1033.         }
  1034.         case QUIT: {
  1035.             short notapproved = TRUE;
  1036.             short oneleft;
  1037.                 /* general purpose GetDItem vars */
  1038.             
  1039.             struct winds ** conp = conns;
  1040.             struct winds * conend = &conp[conncount];
  1041.             register struct winds * twp;
  1042.             
  1043.             appclosing = TRUE;
  1044.             
  1045.             /* go through window list to see who needs service */
  1046.             /* TODO disable window items as we go in case notapproved later... */
  1047.             while (conp < conend) {
  1048.                 twp = *conp++;
  1049.                 if (twp == NULL)
  1050.                     continue;
  1051.             
  1052.                 getcontext(twp);
  1053.                 if (queryconfchange(twp))
  1054.                     goto QUITABORT;
  1055.  
  1056.                 if (!twp->connopen)
  1057.                     continue;
  1058.  
  1059.                 if (twp->conntype == CONN_MACTCP
  1060.                         || twp->conntype == CONN_CUTCP) {
  1061.                         
  1062.                     if (querycloseconn(twp))
  1063.                         goto QUITABORT;
  1064.  
  1065.                     twp->userquit = TRUE;
  1066.         
  1067.                     if (twp->conntype == CONN_MACTCP)
  1068.                         mactcp_close();
  1069. #ifdef DUALTCP
  1070.                     else
  1071.                         tcp_close();
  1072. #endif
  1073.                     twp->ucb.u_state = CLOSING;
  1074.                     twp->ucb.u_rstate = BLOCK;
  1075.                     bkrd_service();
  1076.                 }
  1077.                 else if (twp->conntype == CONN_SERD) {
  1078.                     if (querycloseconn(twp))
  1079.                         goto QUITABORT;
  1080.  
  1081.                     closeserport(twp);
  1082.                     cls_usr();
  1083.                 }
  1084.             }
  1085.             
  1086.     /* sometimes MacTCP fails to call the ASR to set mtevent & closeflag
  1087.         and leaves us hanging in this loop?  */
  1088.             /* loop for a while until close legitimately */
  1089.             while (TRUE) {
  1090.                 oneleft = FALSE;
  1091.                 for (conp = conns; conp < conend; ) {
  1092.                     twp = *conp++;
  1093.                     if (twp == NULL)
  1094.                         continue;
  1095.                 
  1096.                     if (twp->connopen)
  1097.                         oneleft = TRUE;
  1098.                 }
  1099.                 if (!oneleft)
  1100.                     break;
  1101.                 bkrd_service();
  1102.             }
  1103.             
  1104.             /* release the streams or whatever... */
  1105.             for (conp = conns; conp < conend; ) {
  1106.                 twp = *conp++;
  1107.                 if (twp == NULL)
  1108.                     continue;
  1109.                 
  1110.                 getcontext(twp);
  1111.                 
  1112.                 if (twp->conntype == CONN_MACTCP) {
  1113.                     tcp_release(twp);
  1114.                 }
  1115. #ifdef DUALTCP
  1116.                 else if (twp->conntype == CONN_CUTCP) {
  1117.                     /* cleanup is automatic via exit_hooks */
  1118.                     ;
  1119.                 }
  1120. #endif
  1121.                 /* TODO tftp ? */
  1122.             }
  1123.             sercleanup();
  1124.             cu_exit(0);
  1125.             break;
  1126.         }
  1127.         default:
  1128.             break;
  1129.     }
  1130.     return;
  1131.     
  1132. QUITABORT:
  1133.     appclosing = FALSE;
  1134.     return;
  1135. }
  1136.  
  1137.  
  1138. /* handle edit menu commands; emwindow commands put on q, text handled promptly */
  1139.  
  1140. #ifdef USETEXTWINDFIND
  1141. #define FINDMAX     1000
  1142. #define FORWARD     1
  1143. #define BACKWARD    2
  1144. #endif
  1145.  
  1146. menuedit(theItem)
  1147. short theItem;
  1148. {
  1149.     switch (theItem) {
  1150.         case EDCUT: {
  1151.             if (keydp->edit) {
  1152.                 textwcut(keydp);
  1153.                 if (mfpresent)
  1154.                     /* make sure mf updates all client's scrap info */
  1155.                     SystemEdit(EDCOPY - 1);
  1156.             }
  1157.             else {
  1158.                 getcontext(keydp);
  1159.                 stdedit((unsigned char) ED_COPY);
  1160.                     /* won't handle cut so just do a copy */
  1161.             }
  1162.             break;
  1163.         }
  1164.         case EDCLEAR: {
  1165.             if (keydp->edit) {
  1166.                 textwclear(keydp);
  1167.             }
  1168.             break;
  1169.         }
  1170.         case EDCOPY: {
  1171.             if (keydp->edit) {
  1172.                 /* we're in text editor, do it the easy way TODO should support append */
  1173.                 textwcopy(keydp);
  1174.                 if (mfpresent)
  1175.                     /* make sure mf updates all client's scrap info */
  1176.                     SystemEdit(EDCOPY - 1);
  1177.             }
  1178.             else {
  1179.                 getcontext(keydp);
  1180.                 stdedit((unsigned char) ED_COPY);
  1181.                     /* won't handle cut so just do a copy */
  1182.             }
  1183.             break;
  1184.         }
  1185.         case EDPASTE: {
  1186.             if (keydp->edit) {
  1187.                 textwpaste(keydp);
  1188.             }
  1189.             else
  1190.                 keyputaction(RSLT_EDIT, ED_PASTE);
  1191.                 /* do this on the q because it interacts with host */
  1192.             break;
  1193.         }
  1194.         case EDSELALL: {
  1195.             if (keydp->edit) {
  1196.                 tesetsel( (long) 0, (long) (*keydp->texthand)->teLength, keydp->texthand);
  1197.             }
  1198.             else {
  1199.                 getcontext(keydp);
  1200.                 stdedit((unsigned char) ED_SELALL);
  1201.                     /* won't handle cut so just do a copy */
  1202.             }
  1203.             break;
  1204.         }
  1205.         case EDLOAD: {
  1206.             /* append a file selected by the user to the .edit window */
  1207.             Point here;
  1208.             SFReply sftypereply;
  1209.             SFTypeList typelist;
  1210.             
  1211.             if (chkbackground())
  1212.                 break;
  1213.                 
  1214.             sftypereply.good = FALSE;
  1215.             emwdeactivate();
  1216.             
  1217.             here.v = 60;
  1218.             here.h = 100;
  1219.             centerpoint(&here);
  1220.             
  1221.             typelist[0] = 'TEXT';
  1222.             
  1223.             getcontext(keydp);
  1224.             modaldialog = TRUE;
  1225.  
  1226.             *SFSaveDisk = - emdp->downvol;
  1227.             *CurDirStore = emdp->downdir;
  1228.         
  1229.             /* TODO kevin should have application name if not launched from document */
  1230.             SFGetFile(pass(here), "\PAppend file to .edit window", 
  1231.                  (ProcPtr) SFnofilter, 1, &typelist, (ProcPtr) NULL, &sftypereply);
  1232.  
  1233.             modaldialog = FALSE;
  1234.             if (sftypereply.good) {
  1235.                 /* stick name in at cursor position */
  1236.                 char * chp;
  1237.                 char * endp;
  1238.                 struct token atoke;
  1239.                 WDPBRec WDPB;    
  1240.                 
  1241.                 SetVol((StringPtr) NULL, sftypereply.vRefNum);
  1242.                 emdp->downvref = sftypereply.vRefNum;
  1243.  
  1244.                 WDPB.ioCompletion = NULL;
  1245.                 WDPB.ioNamePtr = NULL;
  1246.                 PBHGetVol(&WDPB, (Boolean) FALSE);    
  1247.                 emdp->downvol = WDPB.ioWDVRefNum;
  1248.                 emdp->downdir = WDPB.ioWDDirID;
  1249.                     /* modify the download directory, save for the next SFget dialog */
  1250.  
  1251.                 ptoc(&sftypereply.fName[0]);
  1252.                 textwload(&sftypereply.fName[0]);
  1253.                 ctop(&sftypereply.fName[0]);
  1254.             }
  1255.             break;
  1256.         }
  1257.         case EDAPPEND: {
  1258.             getcontext(keydp);
  1259.             stdedit((unsigned char) ED_APPEND);
  1260.             break;
  1261.         }
  1262.         case EDTABLEMODE: {
  1263.             /* toggle the copy table mode */
  1264.             keydp->copytable = !keydp->copytable;
  1265.             CheckItem(menu[EDITMENU], EDTABLEMODE, keydp->copytable ? TRUE : FALSE);
  1266.             break;
  1267.         }
  1268.         case LOGSESSION: {
  1269.             getcontext(keydp);
  1270.             keydp->logsession = !keydp->logsession;
  1271.             CheckItem(menu[EDITMENU], LOGSESSION, keydp->logsession ? TRUE : FALSE);
  1272.             showtape();
  1273.             break;
  1274.         }
  1275. #ifdef USETEXTWINDOWS
  1276. #ifdef USETEXTWINDFIND
  1277.         /* possibly no one will approve of adding a search feature anyway... */
  1278.         
  1279.         case EDFINDSEL:        /* really find same... */
  1280. #ifdef REALLYFINDSEL                
  1281.             texthand = keydp->texthand;
  1282.             selstart = (*texthand)->selStart;
  1283.             selend = (*texthand)->selEnd;
  1284.             if (selstart != selend)  {
  1285.                 /* if text selected, copy select range to string buffer */
  1286.                 textncopy(*(*texthand)->hText + selstart, fstring, 
  1287.                     selend - selstart, FINDMAX);
  1288.             }
  1289. #else
  1290.             if (fstring[0] == '\000')
  1291.                 /* the search string hasn't been set yet, do dialog */
  1292.                 theItem = EDFIND;
  1293. #endif
  1294.         case EDFIND:    {
  1295.             /* present a dialog to get the string to find */
  1296.             TEHandle     texthand;        /* top window text record */
  1297.             long     loc, count;
  1298.             int selstart, selend;
  1299.             int direction;
  1300.  
  1301.             texthand = keydp->texthand;
  1302.             selstart = (*texthand)->selStart;
  1303.             selend = (*texthand)->selEnd;
  1304.  
  1305.             if (theItem == EDFIND) {
  1306.                 /* use the selection (if it exists) in the find dialog */
  1307.                 texthand = keydp->texthand;
  1308.                 selstart = (*texthand)->selStart;
  1309.                 selend = (*texthand)->selEnd;
  1310.                 if (selstart != selend)  {
  1311.                     /* if text selected, copy select range to string buffer */
  1312.                     textncopy(*(*texthand)->hText + selstart, &fstring[0], 
  1313.                         selend - selstart, FINDMAX);
  1314.                 }
  1315.             }
  1316.             if (myEvent.modifiers & shiftKey) {
  1317.                 direction = BACKWARD;
  1318.                 if (theItem == EDFIND) {
  1319.                     if (querytext("Search back in edit window for:", &fstring[0]))
  1320.                         break;
  1321.                 }
  1322.             }
  1323.             else {
  1324.                 direction = FORWARD;
  1325.                 if (theItem == EDFIND) {
  1326.                     if (querytext("Search in edit window for:", &fstring[0]))
  1327.                         break;
  1328.                 }
  1329.             }
  1330.             
  1331.             if ( (count = findstring(texthand, &loc, direction)) > 0)  {
  1332.                 /* found a match of the fstring */
  1333.                 tesetsel(loc,  (long) (loc + count), texthand);
  1334.             }
  1335.             else {
  1336.                 /* reset selection to insertion point and beep to indicate failure */
  1337.                 tesetsel((long) (*texthand)->selStart, 
  1338.                     (long) (*texthand)->selStart, texthand);
  1339.                 SysBeep(30);
  1340.             }
  1341.             
  1342.             SelView(keydp);
  1343.             break;
  1344.         }
  1345. #endif
  1346.         case EDGOTOEND: {
  1347. #ifdef BRINGTEXTUP
  1348.             if (keywindow == keydp->emwindow) {
  1349.                 if (keydp->hidetextwindow) {
  1350.                     keydp->hidetextwindow = FALSE;
  1351.                 }
  1352.                 selectwindow(keydp->textwindow);
  1353.                 ShowWindow(keydp->textwindow);
  1354.             }
  1355. #endif
  1356.             textwgotoend(keydp);
  1357.             break;
  1358.         }
  1359.         case EDPAGEUP: {
  1360.             WindowPtr oport;
  1361.             
  1362.             GetPort(&oport);
  1363.             SetPort(keydp->textwindow);
  1364.             ScrollToLine(keydp, max( 0, min( keydp->FirstLine + -keydp->textlines, ScrollMax(keydp) ) ) );
  1365.             SetPort(oport);
  1366.             break;
  1367.         }
  1368.         case EDPAGEDOWN: {
  1369.             WindowPtr oport;
  1370.             
  1371.             GetPort(&oport);
  1372.             SetPort(keydp->textwindow);
  1373.             ScrollToLine(keydp, max( 0, min( keydp->FirstLine + keydp->textlines, ScrollMax(keydp) ) ) );
  1374.             SetPort(oport);
  1375.             break;
  1376.         }
  1377.         case EDWRAP: {
  1378.             textwwrap(keydp);
  1379.             break;
  1380.         }
  1381.         case EDUNWRAP: {
  1382.             textwunwrap(keydp);
  1383.             break;
  1384.         }
  1385. #endif
  1386.         default:
  1387.             return;
  1388.     }
  1389. }
  1390.  
  1391.  
  1392.  
  1393. menunetwork(theItem)
  1394. short theItem;
  1395. {
  1396.     switch (theItem) {
  1397.         case SENDADDR: {
  1398.             /* echo our address to the host */
  1399.             char buffer[25];
  1400.             
  1401.             if (rnet == NULL)
  1402.                 break;
  1403.                 
  1404.             getcontext(keydp);
  1405.             sprintf(buffer, "%a", rnet->ip_addr);
  1406.             (*keydp->sendstr)(buffer);
  1407.             break;
  1408.         }
  1409.         case NETSTAT: {
  1410.             if (keydp->conntype == CONN_MACTCP)
  1411.                 mactcp_status();
  1412. #ifdef DUALTCP
  1413.             else if (keydp->conntype == CONN_CUTCP)
  1414.                 tc_status();
  1415. #endif
  1416.             break;
  1417.         }
  1418.         case ENDOFLINE: {
  1419.             if (keydp->ucb.u_sendm != NEWLINE) {
  1420.                 setsendm(NEWLINE);
  1421.                 keydp->ucb.u_sendm = NEWLINE;
  1422.             }
  1423.             else {
  1424.                 setsendm(EVERYC);
  1425.                 keydp->ucb.u_sendm = EVERYC;
  1426.             }
  1427.             break;
  1428.         }
  1429.         case LOCALECHO: {
  1430.             if (keydp->ucb.u_echom != REMOTE) {
  1431.                 echoremote(&keydp->ucb);
  1432.                 keydp->ucb.u_echongo = RECHOREQ;
  1433.             }
  1434.             else {
  1435.                 echolocal(&keydp->ucb);
  1436.                 keydp->ucb.u_echongo = LECHOREQ;
  1437.                 break;
  1438.             }
  1439.             setmecho(keydp->ucb.u_echom);
  1440.             break;
  1441.         }
  1442.     }
  1443. }
  1444.  
  1445. menusersend(theItem)
  1446. short theItem;
  1447. {
  1448.     getcontext(keydp);
  1449.     switch (theItem) {
  1450.         case SYTEKESCAPE: {
  1451.             (*emdp->putchar)(CTLA);
  1452.             (*emdp->putchar)(CTLB);
  1453.             break;
  1454.         }
  1455.         case ALTSYTEKESCAPE: {
  1456.             (*emdp->putchar)(CTLA);
  1457.             (*emdp->putchar)(CTLB);
  1458.             break;
  1459.         }
  1460.     }
  1461. }
  1462.  
  1463.  
  1464. menusend(theItem)
  1465. short theItem;
  1466. {
  1467.     getcontext(keydp);
  1468.     
  1469.     switch (theItem) {
  1470.         case YOUTHERE: {
  1471.             (*keydp->putchar)(TNIAC);
  1472.             (*keydp->putchar)(TNAYT);
  1473.             (*keydp->putflush)();
  1474.             break;
  1475.         }
  1476.         case ABORT: {
  1477.             (*keydp->putchar)(TNIAC);
  1478.             (*keydp->putchar)(TNAO);
  1479.             (*keydp->putflush)();
  1480.             break;
  1481.         }
  1482.         case BREAK: {
  1483.             sendBreak();
  1484.             (*keydp->putflush)();
  1485.             break;
  1486.         }
  1487.         case ERASECHAR: {
  1488.             if (emdp->ibm_mode) 
  1489.                 /* handle this telnet NVT function locally for 3270 */
  1490.                 menucurkey(MBS);
  1491.             else {
  1492.                 (*keydp->putchar)(TNIAC);
  1493.                 (*keydp->putchar)(TNERCH);
  1494.                 (*keydp->putflush)();
  1495.             }
  1496.             break;
  1497.         }
  1498.         case ERASELINE: {
  1499.             if (emdp->ibm_mode) 
  1500.                 /* handle this telnet NVT function locally for 3270 */
  1501.                 menucurkey(MERASEINPUT);
  1502.             else {
  1503.                 (*keydp->putchar)(TNIAC);
  1504.                 (*keydp->putchar)(TNERLN);
  1505.                 (*keydp->putflush)();
  1506.             }
  1507.             break;
  1508.         }
  1509.         case INTERRUPT: {
  1510.             (*keydp->putchar)(TNIAC);
  1511.             (*keydp->putchar)(TNINT);
  1512.             (*keydp->putchar)(TNIAC);
  1513.             (*keydp->putchar)(TNDM);
  1514.             mtcpurgent();
  1515.             (*keydp->putflush)();
  1516.             mtcpclrurgent();
  1517.             dotcpurgent();                /* for Cornell */
  1518.             break;
  1519.         }
  1520.         default:
  1521.             ;
  1522.     }
  1523. }
  1524.  
  1525.  
  1526.  
  1527. /* handle menu items producing ibm 7171 key sequences--cursor motion */
  1528.  
  1529. menucurkey(theItem)
  1530. short theItem;
  1531. {
  1532.     switch(theItem) {
  1533.         case MNEWLINE:     {
  1534.             keyputaction(RSLT_MVCR, NEW_LINE);
  1535.             break;
  1536.         }
  1537.         case MINSERT: {
  1538.             keyputaction(RSLT_LCAC,INSRT);
  1539.             break;
  1540.         }
  1541.         case MRESET: {
  1542.             sendReset();
  1543.             break;
  1544.         }
  1545.         case MBS: {
  1546.             if (keydp->event_reg & INSERT) {
  1547.                 keyputaction(RSLT_LCAC, BACKSP_DEL);
  1548.             }
  1549.             else {
  1550.                 keyputaction(RSLT_LCAC, BACKSP_BLANK);
  1551.             }
  1552.             break;
  1553.         }
  1554.         case MBSDEL: {
  1555.             keyputaction(RSLT_LCAC, BACKSP_DEL);
  1556.             break;
  1557.         }
  1558.         case MBSBLANK: {
  1559.             keyputaction(RSLT_LCAC, BACKSP_BLANK);
  1560.             break;
  1561.         }
  1562.         case MDEL: {
  1563.             keyputaction(RSLT_LCAC,DEL_CHAR);
  1564.             break;
  1565.         }
  1566.         case MTAB: {
  1567.             keyputaction(RSLT_MVCR, TAB_FWD);
  1568.             break;
  1569.         }
  1570.         case MBACKTAB: {
  1571.             keyputaction(RSLT_MVCR, BACK_TAB);
  1572.             break;
  1573.         }
  1574.         case MUP: {
  1575.             keyputaction(RSLT_MVCR,UP_ARROW);
  1576.             break;
  1577.         }
  1578.         case MDOWN: {
  1579.             keyputaction(RSLT_MVCR,DOWN_ARROW);
  1580.             break;
  1581.         }
  1582.         case MLEFT: {
  1583.             keyputaction(RSLT_MVCR,LEFT_ARROW);
  1584.             break;
  1585.         }
  1586.         case MRIGHT: {
  1587.             keyputaction(RSLT_MVCR,RIGHT_ARROW);
  1588.             break;
  1589.         }
  1590.         case MHOME: {
  1591.             keyputaction(RSLT_MVCR,HOME);
  1592.             break;
  1593.         }
  1594.         case MERASEINPUT: {
  1595.             keyputaction(RSLT_LCAC,INPUT_ERASE);
  1596.             break;
  1597.         }
  1598.         case MERASEEOF: {
  1599.             keyputaction(RSLT_LCAC,ERASE_EOF);
  1600.             break;
  1601.         }
  1602.     }
  1603. }
  1604.  
  1605.  
  1606.  
  1607. /* handle menu items producing ibm 7171 key sequences--pf keys */
  1608.  
  1609. menupfkey(theItem)
  1610. short theItem;
  1611. {
  1612.     if (theItem < MPF1) {
  1613.         switch (theItem) {
  1614.             case MENTER: {
  1615.                 keyputaction(RSLT_PFKY, ENTER);
  1616.                 break;
  1617.             }
  1618.             case MPA1: {
  1619.                 keyputaction(RSLT_PFKY,PA1);
  1620.                 break;
  1621.             }
  1622.             case MPA2: {
  1623.                 keyputaction(RSLT_PFKY,PA2);
  1624.                 break;
  1625.             }
  1626.             case MPA3: {
  1627.                 keyputaction(RSLT_PFKY,PA3);
  1628.                 break;
  1629.             }
  1630.             case MCLEAR: {
  1631.                 keyputaction(RSLT_PFKY,CLEAR);
  1632.                 break;
  1633.             }
  1634.         }
  1635.         return;
  1636.     }
  1637.     if (myEvent.modifiers & shiftKey)
  1638.         /* do a shift */
  1639.         keyputaction(RSLT_PFKY, PFSHIFT);
  1640.     switch (theItem) {
  1641.         case MPF1: {
  1642.             keyputaction(RSLT_PFKY,PF1);
  1643.             break;
  1644.         }
  1645.         case MPF2: {
  1646.             keyputaction(RSLT_PFKY,PF2);
  1647.             break;
  1648.         }
  1649.         case MPF3: {
  1650.             keyputaction(RSLT_PFKY,PF3);
  1651.             break;
  1652.         }
  1653.         case MPF4: {
  1654.             keyputaction(RSLT_PFKY,PF4);
  1655.             break;
  1656.         }
  1657.         case MPF5: {
  1658.             keyputaction(RSLT_PFKY,PF5);
  1659.             break;
  1660.         }
  1661.         case MPF6: {
  1662.             keyputaction(RSLT_PFKY,PF6);
  1663.             break;
  1664.         }
  1665.         case MPF7: {
  1666.             keyputaction(RSLT_PFKY,PF7);
  1667.             break;
  1668.         }
  1669.         case MPF8: {
  1670.             keyputaction(RSLT_PFKY,PF8);
  1671.             break;
  1672.         }
  1673.         case MPF9: {
  1674.             keyputaction(RSLT_PFKY,PF9);
  1675.             break;
  1676.         }
  1677.         case MPF10: {
  1678.             keyputaction(RSLT_PFKY,PF10);
  1679.             break;
  1680.         }
  1681.         case MPF11: {
  1682.             keyputaction(RSLT_PFKY,PF11);
  1683.             break;
  1684.         }
  1685.         case MPF12: {
  1686.             keyputaction(RSLT_PFKY,PF12);
  1687.             break;
  1688.         }
  1689.         default:
  1690.             break;
  1691.     }
  1692. }
  1693.  
  1694.  
  1695.  
  1696. /* do disgusting things with the menu as the key interpretation shifts 
  1697.     around to account for the loss of Enter on Mac +, etc.
  1698.  
  1699.     this routine is included in all three applications due to menu differences 
  1700.     */
  1701.  
  1702. pfmenuhack(twp)
  1703. struct winds * twp;
  1704. {
  1705.     if (keyboard == OLDKEYBOARD) {
  1706.         SetItem(menu[PFKEYMENU], MPA1, "\PPA1              SH-Enter");
  1707.         SetItem(menu[PFKEYMENU], MPA2, "\PPA2              Enter");
  1708.         SetItem(menu[PFKEYMENU], MPA3, "\PPA3             \021Enter");
  1709.         SetItem(menu[PFKEYMENU], MCLEAR, "\PClear           OP-Enter");
  1710.     }
  1711.     else {
  1712.         /* mac + keyboard */
  1713.         switch (twp->keypad) {
  1714.             case NORMKEYPAD: {
  1715.                 SetItem(menu[PFKEYMENU], MPA1, "\PPA1");
  1716.                 SetItem(menu[PFKEYMENU], MPA2, "\PPA2");
  1717.                 SetItem(menu[PFKEYMENU], MPA3, "\PPA3");
  1718.                 SetItem(menu[PFKEYMENU], MCLEAR, "\PClear           Clear");
  1719.                 break;
  1720.             }
  1721.             case KEYPAD1: {
  1722.                 SetItem(menu[PFKEYMENU], MPA1, "\PPA1              KP *");
  1723.                 SetItem(menu[PFKEYMENU], MPA2, "\PPA2              KP -");
  1724.                 SetItem(menu[PFKEYMENU], MPA3, "\PPA3             \021KP -");
  1725.                 SetItem(menu[PFKEYMENU], MCLEAR, "\PClear           KP +");
  1726.                 break;
  1727.             }
  1728.             case KEYPAD3:
  1729.             case KEYPAD2: {
  1730.                 SetItem(menu[PFKEYMENU], MPA1, "\PPA1              SH-KP 0");
  1731.                 SetItem(menu[PFKEYMENU], MPA2, "\PPA2              KP 0");
  1732.                 SetItem(menu[PFKEYMENU], MPA3, "\PPA3             \021KP 0");
  1733.                 SetItem(menu[PFKEYMENU], MCLEAR, "\PClear           OP-KP 0");
  1734.                 break;
  1735.             }
  1736.         }
  1737.     }
  1738. }
  1739.  
  1740.  
  1741. setmenuaddresses(hhostname, hostp)
  1742. StringHandle hhostname;
  1743. struct hostsock * hostp;
  1744. {
  1745.     char buffer[255];
  1746.     
  1747.     if (rnet == NULL)
  1748.         return;
  1749.         
  1750.     sprintf(buffer, "My Address -- %a", rnet->ip_addr);
  1751.     ctop(buffer);
  1752.     SetItem(menu[NETWORKMENU], MYADDR, buffer);
  1753.  
  1754.     HLock(hhostname);
  1755.     ptoc(*hhostname);
  1756.     sprintf(buffer, "Host:  %s", *hhostname);
  1757.     ctop(*hhostname);
  1758.     HUnlock(hhostname);
  1759.  
  1760.     ctop(buffer);
  1761.     SetItem(menu[NETWORKMENU], HOSTNAME, buffer);
  1762.  
  1763.     sprintf(buffer, "Host Address -- %a", hostp->u.addr);
  1764.     ctop(buffer);
  1765.     SetItem(menu[NETWORKMENU], HOSTADDR, buffer);
  1766.  
  1767.     /* TODO find gateway address for MacTCP */
  1768. #ifdef DUALTCP
  1769.     if (emdp->conntype == CONN_CUTCP) {
  1770.         sprintf(buffer, "Gateway Address -- %a", rnet->n_defgw);
  1771.         ctop(buffer);
  1772.         SetItem(menu[NETWORKMENU], GATEADDR, buffer);
  1773.     }
  1774. #endif
  1775. }
  1776.  
  1777.  
  1778. /* set/reset the session related menus; returns TRUE if menu bar needs
  1779.     redrawing */
  1780.  
  1781. setmsession(twp)
  1782. struct winds * twp;
  1783. {
  1784.     static char menusession = 1;
  1785.     static char ibm_keymode = 1;
  1786.     
  1787.     if (twp->connopen == menusession && twp->ibm_keymode == ibm_keymode)
  1788.         /* first time, never */
  1789.         return(FALSE);
  1790.         
  1791.     menusession = twp->connopen;
  1792.     ibm_keymode = twp->ibm_keymode;
  1793.     
  1794.     if (twp->connopen) {
  1795.         /* a connection is open for the top window */
  1796. #ifdef USEABORT
  1797.         EnableItem(menu[WINDMENU], REOPENCONN);
  1798.         SetItem(menu[WINDMENU], OPENCONN, "\PClose session");
  1799. #else
  1800.         EnableItem(menu[WINDMENU], CLOSECONN);
  1801.         DisableItem(menu[WINDMENU], REOPENCONN);
  1802. #endif
  1803.         
  1804.         EnableItem(menu[SENDMENU], 0);
  1805.         if (twp->ibm_keymode) {
  1806.             EnableItem(menu[CURKEYMENU], 0);
  1807.             EnableItem(menu[PFKEYMENU], 0);
  1808.         }
  1809.         else {
  1810.             EnableItem(menu[ASC1KEYMENU], 0);
  1811.             EnableItem(menu[ASC2KEYMENU], 0);
  1812.         }
  1813.     }
  1814.     else {
  1815. #ifdef USEABORT
  1816.         DisableItem(menu[WINDMENU], REOPENCONN);
  1817.         SetItem(menu[WINDMENU], CLOSECONN, "\PRe-open session");
  1818. #else
  1819.         DisableItem(menu[WINDMENU], CLOSECONN);
  1820.         EnableItem(menu[WINDMENU], REOPENCONN);
  1821. #endif
  1822.         /* SetItemCmd(menu[WINDMENU], CLOSECONN, (char) 'R'); */
  1823.  
  1824.         DisableItem(menu[SENDMENU], 0);
  1825.  
  1826.         if (twp->ibm_keymode) {
  1827.             DisableItem(menu[CURKEYMENU], 0);
  1828.             DisableItem(menu[PFKEYMENU], 0);
  1829.         }
  1830.         else {
  1831.             DisableItem(menu[ASC1KEYMENU], 0);
  1832.             DisableItem(menu[ASC2KEYMENU], 0);
  1833.         }
  1834.     }
  1835.     return(TRUE);    
  1836. }
  1837.  
  1838.  
  1839. /* enable the ibm keys, can't do through setmesesssion, already fixed OK if ASCII */
  1840.  
  1841. ibmkeyenable()
  1842. {
  1843.     EnableItem(menu[CURKEYMENU], 0);
  1844.     EnableItem(menu[PFKEYMENU], 0);
  1845.     DrawMenuBar();
  1846. }
  1847.  
  1848.  
  1849. /* turn the "send" items in the network (telnet/serial) menu on or off */
  1850.  
  1851. msetsendm(flag)
  1852. short flag;
  1853. {
  1854.     if (emdp->conntype == CONN_MACTCP
  1855.         || emdp->conntype == CONN_CUTCP) {
  1856.             if (flag)
  1857.                 EnableItem(menu[SENDMENU], 0);
  1858.             else
  1859.                 DisableItem(menu[SENDMENU], 0);
  1860.     }
  1861.     else if (emdp->conntype == CONN_SERD) {
  1862. #ifdef USESERSEND
  1863.         if (flag)
  1864.             EnableItem(menu[SERSENDMENU], 0);
  1865.         else
  1866.             DisableItem(menu[SERSENDMENU], 0);
  1867. #else
  1868.         if (flag)
  1869.             EnableItem(menu[SERIALMENU], 1);
  1870.         else
  1871.             DisableItem(menu[SERIALMENU], 1);
  1872. #endif
  1873.     }
  1874. }
  1875.  
  1876.  
  1877. /* change the emulator edit menu as we are activated/deactivated */
  1878.  
  1879. emedit(twp, flag)
  1880. struct winds * twp;
  1881. short flag;
  1882. {
  1883.     if (twp == NULL)
  1884.         twp = emdp;
  1885.         
  1886.     if (flag) {
  1887.         if (!connavailable) {
  1888.             /* emulator window is active and is
  1889.                 being activated, set edit menu accordingly */
  1890.             
  1891.             /* enable the menus */
  1892.             EnableItem(menu[EDITMENU], 0);
  1893.             EnableItem(menu[FILEMENU], 0);
  1894.             EnableItem(menu[WINDMENU], 0);
  1895.             EnableItem(menu[HELPMENU], 0);
  1896.     
  1897.             enablecontrolmenu();
  1898.  
  1899.             /* disable edit menu items we don't support */
  1900.             DisableItem(menu[EDITMENU], EDUNDO);
  1901.  
  1902.             /* enable edit menu items */
  1903.             EnableItem(menu[EDITMENU], EDTABLEMODE);
  1904.             EnableItem(menu[EDITMENU], EDLOAD);
  1905.             EnableItem(menu[EDITMENU], EDAPPEND);
  1906.             EnableItem(menu[EDITMENU], LOGSESSION);
  1907. #ifdef USETEXTWINDOWS
  1908.             if (twp->edit) {
  1909.                 EnableItem(menu[EDITMENU], EDCUT);
  1910.                 EnableItem(menu[EDITMENU], EDCLEAR);
  1911.             }
  1912.             else {
  1913.                 DisableItem(menu[EDITMENU], EDCUT);
  1914.                 DisableItem(menu[EDITMENU], EDCLEAR);
  1915.             }
  1916. #else
  1917.             DisableItem(menu[EDITMENU], EDCUT);
  1918. #endif
  1919. #ifdef USETEXTWINDOWS
  1920.             EnableItem(menu[EDITMENU], EDPAGEUP);
  1921.             EnableItem(menu[EDITMENU], EDPAGEDOWN);
  1922.             EnableItem(menu[EDITMENU], EDGOTOEND);
  1923.             EnableItem(menu[EDITMENU], EDFIND);
  1924.             EnableItem(menu[EDITMENU], EDFINDSEL);
  1925.             EnableItem(menu[EDITMENU], EDWRAP);
  1926.             EnableItem(menu[EDITMENU], EDUNWRAP);
  1927. #endif
  1928.             
  1929.             /* guarantee file menu items are enabled */
  1930. #ifdef USEABORT
  1931.             EnableItem(menu[WINDMENU], CLOSECONN);
  1932.             EnableItem(menu[WINDMENU], REOPENCONN);
  1933. #else
  1934.             if (twp->connopen) {
  1935.                 EnableItem(menu[WINDMENU], CLOSECONN);
  1936.                 DisableItem(menu[WINDMENU], REOPENCONN);
  1937.             }
  1938.             else {
  1939.                 DisableItem(menu[WINDMENU], CLOSECONN);
  1940.                 EnableItem(menu[WINDMENU], REOPENCONN);
  1941.             }
  1942. #endif
  1943.             EnableItem(menu[WINDMENU], RECONF);
  1944.             
  1945.             EnableItem(menu[FILEMENU], WMCLOSEWIND);
  1946.             EnableItem(menu[FILEMENU], SAVECONF);
  1947.             EnableItem(menu[FILEMENU], FILENAME);
  1948.             EnableItem(menu[FILEMENU], APPENDSCREEN);
  1949.             EnableItem(menu[FILEMENU], SAVESCREEN);
  1950.             EnableItem(menu[FILEMENU], SAVESCREENAS);
  1951.             EnableItem(menu[FILEMENU], APPENDSCREENTO);
  1952.             EnableItem(menu[FILEMENU], LOGOPEN);
  1953.             EnableItem(menu[FILEMENU], FILESESSION);
  1954.             EnableItem(menu[FILEMENU], PRINTQD);
  1955.     
  1956.             if (twp->conntype == CONN_MACTCP
  1957.                 || twp->conntype == CONN_CUTCP)  {
  1958.                     EnableItem(menu[NETWORKMENU], 0);
  1959.                     EnableItem(menu[SENDMENU], 0);
  1960.             }
  1961.             else if (twp->conntype == CONN_SERD) {
  1962.                     EnableItem(menu[SERIALMENU], 0);
  1963. #ifdef USESERSEND
  1964.                     EnableItem(menu[SERSENDMENU], 0);
  1965. #else
  1966.                     EnableItem(menu[SERIALMENU], 1);
  1967. #endif
  1968.             }
  1969.             if (twp->ibm_keymode) {
  1970.                 EnableItem(menu[CURKEYMENU], 0);
  1971.                 EnableItem(menu[PFKEYMENU], 0);
  1972.             }
  1973.             else {
  1974.                 EnableItem(menu[ASC1KEYMENU], 0);
  1975.                 EnableItem(menu[ASC2KEYMENU], 0);
  1976.             }
  1977.         }
  1978.         else {
  1979.             /* we're turning menus off because no connection exists,
  1980.                 allow the user to make one! */
  1981.             EnableItem(menu[FILEMENU], 0);
  1982.             EnableItem(menu[HELPMENU], 0);
  1983.  
  1984.             DisableItem(menu[EDITMENU], 0);
  1985.             DisableItem(menu[WINDMENU], 0);
  1986.             /*
  1987.                 DisableItem(menu[WINDMENU], CLOSECONN);
  1988.                 DisableItem(menu[WINDMENU], REOPENCONN);
  1989.                 DisableItem(menu[FILEMENU], RECONF);
  1990.             /*
  1991.             
  1992.             disablecontrolmenu();
  1993.     
  1994.                 /* set the file menu */
  1995.             EnableItem(menu[FILEMENU], NEWCONN);
  1996.             EnableItem(menu[FILEMENU], OPENCONN);
  1997.             
  1998.             DisableItem(menu[FILEMENU], WMCLOSEWIND);
  1999.             DisableItem(menu[FILEMENU], SAVECONF);
  2000.             DisableItem(menu[FILEMENU], FILENAME);
  2001.             DisableItem(menu[FILEMENU], APPENDSCREEN);
  2002.             DisableItem(menu[FILEMENU], SAVESCREEN);
  2003.             DisableItem(menu[FILEMENU], SAVESCREENAS);
  2004.             DisableItem(menu[FILEMENU], APPENDSCREENTO);
  2005.             DisableItem(menu[FILEMENU], LOGOPEN);
  2006.             DisableItem(menu[FILEMENU], FILESESSION);
  2007.             DisableItem(menu[FILEMENU], PRINTQD);
  2008.     
  2009.             /* disable other menus */
  2010.             if (twp->conntype == CONN_MACTCP
  2011.                 || twp->conntype == CONN_CUTCP)  {
  2012.                     DisableItem(menu[NETWORKMENU], 0);
  2013.                     DisableItem(menu[SENDMENU], 0);
  2014.             }
  2015.             else if (twp->conntype == CONN_SERD) {
  2016.                     DisableItem(menu[SERIALMENU], 0);
  2017. #ifdef USESERSEND
  2018.                     DisableItem(menu[SERSENDMENU], 0);
  2019. #else
  2020.                     DisableItem(menu[SERIALMENU], 1);
  2021. #endif
  2022.             }
  2023.             if (twp->ibm_keymode) {
  2024.                 DisableItem(menu[CURKEYMENU], 0);
  2025.                 DisableItem(menu[PFKEYMENU], 0);
  2026.             }
  2027.             else {
  2028.                 DisableItem(menu[ASC1KEYMENU], 0);
  2029.                 DisableItem(menu[ASC2KEYMENU], 0);
  2030.             }
  2031.         }
  2032.     }
  2033.     else {
  2034.         /* !flag, set up menus for DA's */
  2035.         EnableItem(menu[EDITMENU], EDUNDO);
  2036.         EnableItem(menu[EDITMENU], EDCUT);
  2037.         EnableItem(menu[EDITMENU], EDCLEAR);
  2038.         EnableItem(menu[EDITMENU], EDSELALL);
  2039.         
  2040.         DisableItem(menu[EDITMENU], EDTABLEMODE);
  2041.  
  2042.         DisableItem(menu[EDITMENU], EDLOAD);
  2043.         DisableItem(menu[EDITMENU], EDAPPEND);
  2044.         DisableItem(menu[EDITMENU], LOGSESSION);
  2045. #ifdef USETEXTWINDOWS
  2046.         DisableItem(menu[EDITMENU], EDPAGEUP);
  2047.         DisableItem(menu[EDITMENU], EDPAGEDOWN);
  2048.         DisableItem(menu[EDITMENU], EDGOTOEND);
  2049.         DisableItem(menu[EDITMENU], EDFIND);
  2050.         DisableItem(menu[EDITMENU], EDFINDSEL);
  2051.         DisableItem(menu[EDITMENU], EDWRAP);
  2052.         DisableItem(menu[EDITMENU], EDUNWRAP);
  2053. #endif
  2054.  
  2055.         EnableItem(menu[FILEMENU], 0);
  2056.                 /* set the file menu, leave it up or won't come back
  2057.                     if no window up...  */
  2058.             EnableItem(menu[FILEMENU], NEWCONN);
  2059.             EnableItem(menu[FILEMENU], OPENCONN);
  2060.             
  2061.             DisableItem(menu[FILEMENU], WMCLOSEWIND);
  2062.             DisableItem(menu[FILEMENU], SAVECONF);
  2063.             DisableItem(menu[FILEMENU], FILENAME);
  2064.             DisableItem(menu[FILEMENU], APPENDSCREEN);
  2065.             DisableItem(menu[FILEMENU], SAVESCREEN);
  2066.             DisableItem(menu[FILEMENU], SAVESCREENAS);
  2067.             DisableItem(menu[FILEMENU], APPENDSCREENTO);
  2068.             DisableItem(menu[FILEMENU], LOGOPEN);
  2069.             DisableItem(menu[FILEMENU], FILESESSION);
  2070.             DisableItem(menu[FILEMENU], PRINTQD);
  2071.     
  2072.         /* disable all other items completely */
  2073.         DisableItem(menu[HELPMENU], 0);
  2074.  
  2075.         DisableItem(menu[WINDMENU], 0);
  2076.         /*
  2077.             DisableItem(menu[WINDMENU], CLOSECONN);
  2078.             DisableItem(menu[WINDMENU], REOPENCONN);
  2079.             DisableItem(menu[WINDMENU], RECONF);
  2080.         */
  2081.  
  2082.         DisableItem(menu[CTRLMENU], 0);
  2083.  
  2084.         if (twp->conntype == CONN_MACTCP
  2085.             || twp->conntype == CONN_CUTCP)  {
  2086.                 DisableItem(menu[NETWORKMENU], 0);
  2087.                 DisableItem(menu[SENDMENU], 0);
  2088.         }
  2089.         else if (twp->conntype == CONN_SERD) {
  2090.                 DisableItem(menu[SERIALMENU], 0);
  2091. #ifdef USESERSEND
  2092.                 DisableItem(menu[SERSENDMENU], 0);
  2093. #else
  2094.                 DisableItem(menu[SERIALMENU], 1);
  2095. #endif
  2096.         }
  2097.         if (twp->ibm_keymode) {
  2098.             DisableItem(menu[CURKEYMENU], 0);
  2099.             DisableItem(menu[PFKEYMENU], 0);
  2100.         }
  2101.         else {
  2102.             DisableItem(menu[ASC1KEYMENU], 0);
  2103.             DisableItem(menu[ASC2KEYMENU], 0);
  2104.         }
  2105.     }                
  2106. }
  2107.  
  2108.  
  2109.  
  2110. /* take a pascal string and set the file menu command titles using it */
  2111.  
  2112. filetitles(twp)
  2113. struct winds * twp;
  2114. {
  2115.     char * titp = &twp->reply.fName;
  2116.     char * logtitp = &twp->logreply.fName;
  2117.     char tbuf[256];
  2118.  
  2119.     if (twp->seltype == NULL)
  2120.         return;
  2121.         
  2122.     ptoc(titp);
  2123.  
  2124.     /* if the name is a non-null string, use it...  */
  2125.     sprintf(tbuf, "Save %s%s%s", twp->seltype, *titp ? " as " : "…", titp);
  2126.     ctop(tbuf);
  2127.     SetItem(menu[FILEMENU], SAVESCREEN, tbuf);
  2128.     
  2129.     sprintf(tbuf, "Append %s%s%s", twp->seltype, *titp ? " to " : "…", titp);
  2130.     ctop(tbuf);
  2131.     SetItem(menu[FILEMENU], APPENDSCREEN, tbuf);
  2132.  
  2133.     ctop(titp);
  2134.  
  2135.     /* set Log session title */
  2136.     ptoc(logtitp);
  2137.     sprintf(tbuf, "Log session in %s", logtitp);
  2138.     ctop(tbuf);
  2139.     SetItem(menu[FILEMENU], FILESESSION, tbuf);
  2140.     ctop(logtitp);
  2141. }
  2142.  
  2143.  
  2144. /*    set the titles to menus which work on the screen or selection 
  2145.     to (e.g.) "save screen" or "save selection" as appropriate 
  2146. */
  2147.  
  2148. selmenuitems(twp)
  2149. struct winds * twp;
  2150. {
  2151.     char tbuf[256];
  2152.     
  2153. #ifdef USETEXTWINDOWS
  2154.     /* fix the text for the Append to Edit window */
  2155.     if ((twp->selystart == twp->selyend && twp->selxstart == twp->selxend))
  2156.         /* set the correct default string */
  2157.         twp->seltype = selscreen;
  2158.     else
  2159.         twp->seltype = selselection;
  2160.  
  2161.     sprintf(tbuf, "Append %s to .edit window", twp->seltype);
  2162.     ctop(tbuf);
  2163.     SetItem(menu[EDITMENU], EDAPPEND, tbuf);
  2164. #endif
  2165.  
  2166.     if (twp->edit) {
  2167.         /* edit window is up */
  2168.         twp->seltype = seltext;
  2169.     }
  2170.     else {
  2171.         if ((twp->selystart == twp->selyend && twp->selxstart == twp->selxend))
  2172.             /* set the correct default string */
  2173.             twp->seltype = selscreen;
  2174.         else
  2175.             twp->seltype = selselection;
  2176.     }    
  2177.     filetitles(twp);
  2178.     
  2179.     sprintf(tbuf, "Save %s as…", twp->seltype);
  2180.     ctop(tbuf);
  2181.     SetItem(menu[FILEMENU], SAVESCREENAS, tbuf);
  2182.  
  2183.     sprintf(tbuf, "Append %s to…", twp->seltype);
  2184.     ctop(tbuf);
  2185.     SetItem(menu[FILEMENU], APPENDSCREENTO, tbuf);
  2186.  
  2187. }
  2188.  
  2189.  
  2190. /* if turnon, deactivate ascii stuff & activate ibm stuff; 
  2191.     else vice-versa; returns TRUE if menu bar needs redrawing */
  2192.  
  2193. keymenus(twp)
  2194. struct winds * twp;
  2195. {
  2196.     int returnval = FALSE;
  2197.     static short menuibm_keymode = 1;        /* neither TRUE or FALSE */
  2198.     static beenhere = FALSE;                /* don't delete anything first time through */
  2199.     
  2200.     if (twp->ibm_keymode) {
  2201.         /* reflect IBM key mode in menus */
  2202.         
  2203.         DisableItem(menu[NETWORKMENU], ENDOFLINE);
  2204.         DisableItem(menu[NETWORKMENU], LOCALECHO);
  2205.  
  2206.         if (!beenhere || menuibm_keymode == FALSE) {
  2207.             /* only change the Menu Bar if the mode changed from ASCII to IBM */
  2208.  
  2209.             if (beenhere) {
  2210.                 DeleteMenu(asc1keymenu);
  2211.                 DeleteMenu(asc2keymenu);
  2212.             }
  2213.             beenhere = TRUE;
  2214.             
  2215.             InsertMenu(menu[CURKEYMENU], helpmenu);
  2216.             InsertMenu(menu[PFKEYMENU], helpmenu);
  2217.             returnval = TRUE;
  2218.         }
  2219.  
  2220.         pfmenuhack(twp);
  2221.     }
  2222.     else {
  2223.         /* set ASCII key mode on menus */
  2224.         
  2225.         EnableItem(menu[NETWORKMENU], ENDOFLINE);
  2226.         EnableItem(menu[NETWORKMENU], LOCALECHO);
  2227.  
  2228.         setmenubs(twp->ba_bs);
  2229.  
  2230.         if (!beenhere || menuibm_keymode == TRUE) {
  2231.             /* only change this if we need to... */
  2232.             if (beenhere) {
  2233.                 DeleteMenu(curkeymenu);
  2234.                 DeleteMenu(pfkeymenu);
  2235.             }
  2236.             beenhere = TRUE;
  2237.             
  2238.             InsertMenu(menu[ASC1KEYMENU], helpmenu);
  2239.             InsertMenu(menu[ASC2KEYMENU], helpmenu);
  2240.             returnval = TRUE;
  2241.         }
  2242.     }
  2243.     if (twp->ibm_keymode)
  2244.         menuibm_keymode = TRUE;
  2245.     else
  2246.         menuibm_keymode = FALSE;
  2247.         
  2248. #ifdef USETEXTWINDOWS
  2249.     returnval = TRUE;
  2250.     if (twp->edit) {
  2251.         /* disable cursor motion etc. if edit menu up */
  2252.         if (twp->ibm_keymode) {
  2253.             DisableItem(menu[CURKEYMENU], 0);
  2254.             DisableItem(menu[PFKEYMENU], 0);            
  2255.         }
  2256.         else {
  2257.             DisableItem(menu[ASC1KEYMENU], 0);
  2258.             DisableItem(menu[ASC2KEYMENU], 0);
  2259.         }
  2260.         EnableItem(menu[EDITMENU], EDCUT);
  2261.         EnableItem(menu[EDITMENU], EDCLEAR);
  2262.         EnableItem(menu[EDITMENU], EDFIND);
  2263.         EnableItem(menu[EDITMENU], EDFINDSEL);
  2264.         EnableItem(menu[EDITMENU], EDWRAP);
  2265.         EnableItem(menu[EDITMENU], EDUNWRAP);
  2266.     }
  2267.     else {
  2268.         if (twp->ibm_keymode) {
  2269.             EnableItem(menu[CURKEYMENU], 0);
  2270.             EnableItem(menu[PFKEYMENU], 0);
  2271.         }
  2272.         else {
  2273.             EnableItem(menu[ASC1KEYMENU], 0);
  2274.             EnableItem(menu[ASC2KEYMENU], 0);
  2275.         }
  2276.         DisableItem(menu[EDITMENU], EDCUT);
  2277.         DisableItem(menu[EDITMENU], EDCLEAR);
  2278.         DisableItem(menu[EDITMENU], EDFIND);
  2279.         DisableItem(menu[EDITMENU], EDFINDSEL);
  2280.         DisableItem(menu[EDITMENU], EDWRAP);
  2281.         DisableItem(menu[EDITMENU], EDUNWRAP);
  2282.     }
  2283. #endif
  2284.  
  2285.     return(returnval);
  2286. }
  2287.  
  2288.  
  2289. /* change backspace->DEL checkmark in Control menu and DEL key equiv. in ASCII codes */
  2290.  
  2291. setmenubs(flag)
  2292. short flag;
  2293. {
  2294.     if (flag) {
  2295.         SetItem(menu[ASC2KEYMENU], ASCMENUDEL, "\PDelete is Opt-Backspace");
  2296.     }
  2297.     else {
  2298.         SetItem(menu[ASC2KEYMENU], ASCMENUDEL, "\PDelete is Backspace");
  2299.     }
  2300. }
  2301.  
  2302.  
  2303. setmenureturn(twp)
  2304. struct winds * twp;
  2305. {
  2306.     if (twp->ibm_keymode) {
  2307.         if (twp->crtonl) {
  2308.             SetItem(menu[PFKEYMENU], MENTER, "\PEnter          Shift-Return");
  2309.         }
  2310.         else {
  2311.             SetItem(menu[PFKEYMENU], MENTER, "\PEnter            Return");
  2312.         }
  2313.     }
  2314. }
  2315.  
  2316.  
  2317. /* telnet buffer mode */
  2318.  
  2319. setsendm(mode)
  2320. int mode;
  2321. {
  2322.     if (mode == NEWLINE) {
  2323.         SetItem(menu[NETWORKMENU], ENDOFLINE, "\PSend after Return");
  2324.     }
  2325.     else if (mode == EVERYC) {
  2326.         SetItem(menu[NETWORKMENU], ENDOFLINE, "\POn every character");
  2327.     }
  2328. }
  2329.  
  2330.  
  2331. /* a routine to let telnet set the menu item */
  2332.  
  2333. setmecho(echomode)
  2334. {
  2335.     if (echomode == REMOTE)
  2336.         SetItem(menu[NETWORKMENU], LOCALECHO, "\PRemote echo");
  2337.     else
  2338.         SetItem(menu[NETWORKMENU], LOCALECHO, "\PLocal echo");
  2339. }
  2340.  
  2341.  
  2342. /* shows an ASCII keypad */
  2343.  
  2344. showkeypad()
  2345. {
  2346. }
  2347.  
  2348.  
  2349.  
  2350. menuctrl(theItem)
  2351. short theItem;
  2352. {
  2353.     switch (theItem) {
  2354.         case MSHOWKEYPAD: {
  2355.             if (keydp->ibm_keymode) {
  2356.                 if (setibmkeypad()) {
  2357.                     /* do the keypad dialog */
  2358.                     keydp->confchanged = TRUE;
  2359.                 }
  2360.             }
  2361.             else {
  2362.                 if (setvtkeypad()) {
  2363.                     /* do the keypad dialog */
  2364.                     keydp->confchanged = TRUE;
  2365.                 }
  2366.             }
  2367.             break;
  2368.         }
  2369.         case MSETGLOBAL: {
  2370.             setglobalconf();
  2371.             break;
  2372.         }
  2373.         case MSETWIND: {
  2374.             setwindconf();
  2375.             break;
  2376.         }
  2377.         case MSETEM: {
  2378.             if (keydp->ibm_mode) 
  2379.                 set3270conf();
  2380.             else
  2381.                 setvtconf();
  2382.             break;
  2383.         }
  2384.         case MSETCOLOR: {
  2385.             if (setcolormap())
  2386.                 keydp->confchanged = TRUE;
  2387.             break;
  2388.         }
  2389.         case KEYXSET: {
  2390.             if (querynewconf())
  2391.                 break;
  2392.  
  2393.             setkeydialog();
  2394.             break;
  2395.         }
  2396.         case KEYXON: {
  2397.             togglemacros();
  2398.             keydp->confchanged = TRUE;
  2399.             CheckItem(menu[CTRLMENU], KEYXON, keydp->dokeymacros ? TRUE : FALSE); 
  2400.             break;
  2401.         }
  2402.         case MCONNMACRO: {
  2403.             if (querynewconf())
  2404.                 break;
  2405.                 
  2406.             if (keydp->connmacro)
  2407.                 DisposHandle(keydp->connmacro);
  2408.             keydp->connmacro = setmacro('CONN', 0, "Connection Open macro");
  2409.             break;
  2410.         }
  2411. #ifdef MCLOSEMACRO
  2412.         case MCLOSEMACRO: {
  2413.             if (querynewconf())
  2414.                 break;
  2415.                 
  2416.             if (keydp->closemacro)
  2417.                 DisposHandle(keydp->closemacro);
  2418.             keydp->closemacro = setmacro('CONN', 1, "Connection Close macro");
  2419.             break;
  2420.         }
  2421. #endif
  2422.         case MCLIKMACRO: {
  2423.             if (querynewconf())
  2424.                 break;
  2425.                 
  2426.             if (keydp->clickmacro)
  2427.                 DisposHandle(keydp->clickmacro);
  2428.             keydp->clickmacro = setmacro('CLIK', 0, "Mouse double-click");
  2429.             if (keydp->clickmacro == NULL) {
  2430.                 /* get default double-click macro resource from application res */
  2431.                 keydp->clickmacro = GetResource('CLIK', 0);
  2432.                 if (keydp->clickmacro != NULL)
  2433.                     DetachResource(keydp->clickmacro);
  2434.             }
  2435.             break;
  2436.         }
  2437.         case KEYXSHOW: {
  2438.  
  2439. #ifdef USETEXTWINDOWS
  2440.             /* dump the macros out into the text window */
  2441.             keyxappend(keydp);
  2442. #else
  2443.             keyxdump(OURCHICAGO, 12);
  2444. #endif
  2445.             break;
  2446.         }
  2447.     }
  2448. }
  2449.  
  2450.  
  2451. /* window menu routines */
  2452.  
  2453. /* some API-run sessions may not have a control for the user to play with,
  2454.     see hyperface.c, so we need a separate array of window pointers 
  2455. */
  2456.  
  2457. /* handle window menu items */
  2458.  
  2459. menuwind(theItem)
  2460. short theItem;
  2461. {
  2462.     switch (theItem) {
  2463.         case CLOSECONN: {
  2464.             getcontext(keydp);
  2465.             if (keydp->connopen) {
  2466.                 if (querycloseconn(keydp))
  2467.                     /* user doesn't want to end session */
  2468.                     return();
  2469.     
  2470.                 closeconn(keydp);
  2471.             }
  2472. #ifdef USEABORT
  2473.             else {
  2474.                 /* reopen session */
  2475.                 if (optkeydown()) {
  2476.                     /* give user the opportunity to revise the configuration */
  2477.                     if (namewindow()) {
  2478.                         /* continue if Cancelled */
  2479.                         break;
  2480.                     }
  2481.                 }
  2482.                 openconn(emdp);
  2483.             }
  2484. #endif
  2485.             return();
  2486.         }
  2487.         case REOPENCONN: {
  2488.             /* re-open a connection */
  2489.             if (!keydp->connopen) {
  2490.                 /* reopen session */
  2491.                 getcontext(keydp);
  2492.                 if (optkeydown()) {
  2493.                     /* give user the opportunity to revise the configuration */
  2494.                     if (namewindow()) {
  2495.                         /* continue if Cancelled */
  2496.                         return();
  2497.                     }
  2498.                 }
  2499.                 openconn(emdp);
  2500.             }
  2501.             return();
  2502.         }
  2503. #ifdef USEABORTCONN
  2504.         case REOPENCONN: {
  2505.             short item;
  2506.             DialogPtr dptr;
  2507.             GrafPtr oport;
  2508.             short type;
  2509.             Rect rect;
  2510.             Handle hobj;
  2511.                 /* general purpose GetDItem vars */
  2512.  
  2513.             if (keydp->connopen) {
  2514.                 /* some tcp connection has been attempted */
  2515.                 getcontext(keydp);
  2516.                 
  2517.                 if (chkbackground()) {
  2518.                     /* in background */
  2519.                         resetsendbuf();
  2520.                         cls_usr();
  2521.                 }
  2522.                 else {
  2523.                     /* ask user whether killing connection is really OK */
  2524.                     GetPort(&oport);
  2525.                     if ((dptr = GetNewDialog(KILLDIALOG, (Ptr) NULL, (WindowPtr) -1))
  2526.                             != NULL)  {
  2527.     
  2528.                         emwdeactivate();
  2529.                         
  2530.                         SetPort(dptr);
  2531.                         centerwind(dptr);
  2532.                         
  2533.                         /* hilite "OK" key */
  2534.                         GetDItem(dptr, KILLOK, &type, &hobj, &rect);
  2535.                         buthilite(&rect);
  2536.     
  2537.                         modaldialog = TRUE;
  2538.                         do {
  2539.                             ModalDialog( (ProcPtr) alfilter, &item);
  2540.                         }
  2541.                         while (item == 0);
  2542.     
  2543.                         DisposDialog(dptr);
  2544.                         SetPort(oport);
  2545.                         if (item == KILLOK) {
  2546.                             resetsendbuf();
  2547.                         }
  2548.                     }
  2549.                     modaldialog = FALSE;
  2550.                 }
  2551.             }
  2552.             return();
  2553.         }
  2554. #endif
  2555.         case RECONF: {
  2556.             short oconntype;
  2557.             short otermtype;
  2558.             short oibm_keys;
  2559.             
  2560.             oconntype = keydp->conntype;
  2561.             oibm_keys = keydp->ibm_keymode;
  2562.  
  2563.             if (keydp == emdp)
  2564.                 /* guarantee keydp struct updated, we may setcontext() */
  2565.                 savecontext(emdp);
  2566.             else
  2567.                 getcontext(keydp);
  2568.                 
  2569.             if (namewindow())
  2570.                 /* cancelled */
  2571.                 return;
  2572.                 
  2573.             termreset();
  2574.             
  2575.             if (keydp->connopen && keydp->conntype != oconntype) {
  2576.                 /* can't change in mid-stream */
  2577.                 keydp->conntype = oconntype;
  2578.                 error("Sorry, you can't change the Connection Type while connected!");
  2579.             }
  2580.             if (!keydp->ibm_mode && oibm_keys != keydp->ibm_keymode) {
  2581.                 /* change the key map if not a real 3270 */
  2582.                 setibm_keymode(keydp->ibm_keymode);
  2583.             }
  2584.             gettermtype();
  2585.             return();
  2586.         }
  2587. #ifdef USETEXTWINDOWS
  2588.         case WMROTATE: {
  2589.             /* toggle the edit window */
  2590.             if (keywindow == keydp->emwindow) {
  2591.                 if (keydp->hidetextwindow) {
  2592.                     keydp->hidetextwindow = FALSE;
  2593.                 }
  2594.                 selectwindow(keydp->textwindow);
  2595.                 ShowWindow(keydp->textwindow);
  2596.             }
  2597.             else if (keywindow == keydp->textwindow) {
  2598.                 selectwindow(keydp->emwindow);
  2599.             }
  2600.             return();
  2601.         }
  2602. #endif
  2603.         case WMSKIPWIND: {
  2604.             return();
  2605.         }
  2606.         default: {
  2607.             windmenuselect(theItem - WMFIRSTWIND);
  2608.             break;
  2609.         }
  2610.     }
  2611. }
  2612.  
  2613. /* add a window's title to the menu */
  2614.  
  2615. addwindmenu(windp)
  2616. WindowPtr windp;
  2617. {
  2618.     short count;
  2619.     
  2620.     for (count = 0; count < menuwindowcount; count++) {
  2621.         /* see if any slots are empty */
  2622.         if (menuwindows[count] == NULL) {
  2623.             break;
  2624.         }
  2625.     }
  2626.     /* else count = menuwindowcount, the last slot in line */
  2627.     if (count >= MAXWIND)
  2628.         return(-1);
  2629.  
  2630.     HLock(((WindowPeek) windp)->titleHandle);
  2631.     if (count == menuwindowcount) {
  2632.         /* add another window slot */
  2633.         AppendMenu(menu[WINDMENU], *((WindowPeek) windp)->titleHandle);
  2634.         if (count < 9)
  2635.             /* use Apple-# to select windows */
  2636.             if (environs.systemVersion)
  2637.                 SetItemCmd(menu[WINDMENU], count + WMFIRSTWIND, (char) (count + '1'));
  2638.     }
  2639.     else {
  2640.         /* reset the name of the old one */
  2641.         EnableItem(menu[WINDMENU], count + WMFIRSTWIND);
  2642.         SetItem(menu[WINDMENU], count + WMFIRSTWIND, *((WindowPeek) windp)->titleHandle);
  2643.     }
  2644.     HUnlock(((WindowPeek) windp)->titleHandle);
  2645.     
  2646.     menuwindows[count] = windp;
  2647.     if (count == menuwindowcount)
  2648.         /* we added another slot */
  2649.         menuwindowcount++;
  2650.  
  2651.     return(0);
  2652. }
  2653.  
  2654.  
  2655. /* change a window's title in the menu */
  2656.  
  2657. windmenutitle(twp)
  2658. struct winds * twp;
  2659. {
  2660.     int count;
  2661.     WindowPtr thewind;
  2662.     
  2663.     thewind = NULL;
  2664.     for (count = 0; count < menuwindowcount; count++) {
  2665.         if (menuwindows[count] == twp->emwindow) {
  2666.             thewind = twp->emwindow;
  2667.             break;
  2668.         }
  2669.     }
  2670.     if (count == menuwindowcount)
  2671.         /* couldn't match window */
  2672.         return(-1);
  2673.  
  2674.     HLock(((WindowPeek) thewind)->titleHandle);
  2675.     SetItem(menu[WINDMENU], count + WMFIRSTWIND, *((WindowPeek) thewind)->titleHandle);
  2676.     HUnlock(((WindowPeek) thewind)->titleHandle);
  2677.     
  2678.     return(0);
  2679. }
  2680.  
  2681.  
  2682. /* change a window's mark in the menu */
  2683.  
  2684. windmenumark(twp, mark)
  2685. struct winds * twp;
  2686. int mark;
  2687. {
  2688.     int count;
  2689.     WindowPtr thewind;
  2690.     
  2691.     thewind = NULL;
  2692.     for (count = 0; count < menuwindowcount; count++) {
  2693.         if (menuwindows[count] == twp->emwindow) {
  2694.             thewind = twp->emwindow;
  2695.             break;
  2696.         }
  2697.     }
  2698.     if (count == menuwindowcount)
  2699.         /* couldn't match window */
  2700.         return(-1);
  2701.  
  2702.     SetItemMark(menu[WINDMENU], count + WMFIRSTWIND, (char) mark);
  2703.     
  2704.     return(0);
  2705. }
  2706.  
  2707.  
  2708. /* change a window's style in the menu */
  2709.  
  2710. windmenustyle(twp, mark)
  2711. struct winds * twp;
  2712. int mark;
  2713. {
  2714.     int count;
  2715.     WindowPtr thewind;
  2716.     
  2717.     thewind = NULL;
  2718.     for (count = 0; count < menuwindowcount; count++) {
  2719.         if (menuwindows[count] == twp->emwindow) {
  2720.             thewind = twp->emwindow;
  2721.             break;
  2722.         }
  2723.     }
  2724.     if (count == menuwindowcount)
  2725.         /* couldn't match window */
  2726.         return(-1);
  2727.  
  2728.     SetItemStyle(menu[WINDMENU], count + WMFIRSTWIND, (char) mark);
  2729.     
  2730.     return(0);
  2731. }
  2732.  
  2733.  
  2734. /* change a window's icon in the menu */
  2735.  
  2736. windmenuicon(twp, mark)
  2737. struct winds * twp;
  2738. int mark;
  2739. {
  2740.     int count;
  2741.     WindowPtr thewind;
  2742.     
  2743.     thewind = NULL;
  2744.     for (count = 0; count < menuwindowcount; count++) {
  2745.         if (menuwindows[count] == twp->emwindow) {
  2746.             thewind = twp->emwindow;
  2747.             break;
  2748.         }
  2749.     }
  2750.     if (count == menuwindowcount)
  2751.         /* couldn't match window */
  2752.         return(-1);
  2753.  
  2754.     SetItemIcon(menu[WINDMENU], count + WMFIRSTWIND, (Byte) mark);
  2755.     
  2756.     return(0);
  2757. }
  2758.  
  2759.  
  2760. /* remove the window from the window menu
  2761.     currently simply disables it, should do something fancier 
  2762. */
  2763.  
  2764. killwindmenu(windp)
  2765. WindowPtr windp;
  2766. {
  2767.     short count;
  2768.     
  2769.     for (count = 0; count < menuwindowcount; count++) {
  2770.         if (menuwindows[count] == windp) {
  2771.             SetItemMark(menu[WINDMENU], count + WMFIRSTWIND, (unsigned char) noMark);
  2772.             DisableItem(menu[WINDMENU], count + WMFIRSTWIND);
  2773.             menuwindows[count] = NULL;
  2774.             break;
  2775.         }
  2776.     }
  2777. }
  2778.  
  2779.  
  2780. /* given an item #, select a window */
  2781.  
  2782. windmenuselect(windnum)
  2783. short windnum;
  2784. {
  2785.     GrafPtr thewind;
  2786.     struct winds * twp;
  2787.     
  2788.     if (windnum >= menuwindowcount)
  2789.         return(-1);
  2790.         
  2791.     thewind = menuwindows[windnum];
  2792.     if (thewind == NULL)
  2793.         return(-1);
  2794.         
  2795.     twp = ((WindowPeek) thewind)->refCon;
  2796.     
  2797.     if (twp->icon_up) {
  2798.         expandwindow(twp);
  2799.     }
  2800.     else {
  2801. #ifdef USETEXTWINDOWSCOUPLED
  2802.         if (twp->edit) {
  2803.             selectwindow(twp->textwindow);
  2804.             ShowWindow(twp->textwindow);
  2805.             
  2806.             SendBehind(twp->emwindow, twp->textwindow);
  2807.             ShowWindow(twp->emwindow);
  2808.             PaintOne(twp->emwindow, ((WindowPeek) twp->emwindow)->strucRgn);
  2809.             CalcVis(twp->emwindow);
  2810.         }
  2811.         else {
  2812.             selectwindow(twp->emwindow);
  2813.             ShowWindow(twp->emwindow);
  2814.             
  2815.              if (!twp->hidetextwindow) {
  2816.                 SendBehind(twp->textwindow, twp->emwindow);
  2817.                 ShowWindow(twp->textwindow);
  2818.                 PaintOne(twp->textwindow, ((WindowPeek) twp->textwindow)->strucRgn);
  2819.                 CalcVis(twp->textwindow);
  2820.             }
  2821.         }
  2822. #else
  2823.         selectwindow(twp->emwindow);
  2824.         ShowWindow(twp->emwindow);
  2825. #endif
  2826.     }
  2827. }
  2828.  
  2829.  
  2830. /* make the Control Menu */
  2831.  
  2832. makecontrolmenu(strtitle)
  2833. Str255 * strtitle;
  2834. {
  2835.     menu[CTRLMENU] = NewMenu(ctrlmenu, strtitle);
  2836.     
  2837.     AppendMenu(menu[CTRLMENU], "\PGlobal…");
  2838.     AppendMenu(menu[CTRLMENU], "\PSession…");
  2839.     AppendMenu(menu[CTRLMENU], "\PEmulator…");
  2840.     AppendMenu(menu[CTRLMENU], "\PFont Size");
  2841.     AppendMenu(menu[CTRLMENU], "\PColor…");
  2842.     AppendMenu(menu[CTRLMENU], "\P(-");
  2843.     AppendMenu(menu[CTRLMENU], "\PSet Key Pad…");
  2844. #ifdef USETEXTWINDOWS
  2845.     AppendMenu(menu[CTRLMENU], "\PDump key macros into .edit");
  2846. #else
  2847.     AppendMenu(menu[CTRLMENU], "\PShow macro keys…");
  2848. #endif
  2849.     AppendMenu(menu[CTRLMENU], "\PDefine key macros…/D");
  2850.     AppendMenu(menu[CTRLMENU], "\PKey macros on/M");
  2851.     AppendMenu(menu[CTRLMENU], "\P(-");
  2852.     AppendMenu(menu[CTRLMENU], "\PSet Connection macro…");
  2853.     AppendMenu(menu[CTRLMENU], "\PSet Double-click macro…");
  2854. #ifdef MCLOSEMACRO
  2855.     AppendMenu(menu[CTRLMENU], "\PSet Close macro…");
  2856. #endif
  2857. }
  2858.  
  2859.  
  2860. enablecontrolmenu()
  2861. {
  2862.     EnableItem(menu[CTRLMENU], 0);
  2863.  
  2864.     if (environs.systemVersion) {
  2865.         EnableItem(menu[CTRLMENU], MFONTSIZE);
  2866.     }
  2867.     if (environs.hasColorQD) {
  2868.         /* turn off if color not present */
  2869.         EnableItem(menu[CTRLMENU], MSETCOLOR);
  2870.     }
  2871.     EnableItem(menu[CTRLMENU], MSETWIND);
  2872.     EnableItem(menu[CTRLMENU], MSETEM);
  2873.     EnableItem(menu[CTRLMENU], MSHOWKEYPAD);
  2874.     EnableItem(menu[CTRLMENU], KEYXSHOW);
  2875.     EnableItem(menu[CTRLMENU], KEYXSET);
  2876.     EnableItem(menu[CTRLMENU], KEYXON);
  2877.     EnableItem(menu[CTRLMENU], MCONNMACRO);
  2878. #ifdef MCLOSEMACRO
  2879.     EnableItem(menu[CTRLMENU], MCLOSEMACRO);
  2880. #endif
  2881.     EnableItem(menu[CTRLMENU], MCLIKMACRO);
  2882. }
  2883.  
  2884.  
  2885. /* disable all the items except set global dialog */
  2886.  
  2887. disablecontrolmenu()
  2888. {
  2889.     DisableItem(menu[CTRLMENU], MSETWIND);
  2890.     DisableItem(menu[CTRLMENU], MSETEM);
  2891.     DisableItem(menu[CTRLMENU], MFONTSIZE);
  2892.     DisableItem(menu[CTRLMENU], MSETCOLOR);
  2893.     DisableItem(menu[CTRLMENU], MSHOWKEYPAD);
  2894.     DisableItem(menu[CTRLMENU], KEYXSHOW);
  2895.     DisableItem(menu[CTRLMENU], KEYXSET);
  2896.     DisableItem(menu[CTRLMENU], KEYXON);
  2897.     DisableItem(menu[CTRLMENU], MCONNMACRO);
  2898. #ifdef MCLOSEMACRO
  2899.     DisableItem(menu[CTRLMENU], MCLOSEMACRO);
  2900. #endif
  2901.     DisableItem(menu[CTRLMENU], MCLIKMACRO);
  2902. }
  2903.  
  2904.  
  2905. /* clear out anything in the send buffers */
  2906.  
  2907. resetsendbuf()
  2908. {
  2909.     if (emdp->conntype == CONN_MACTCP) {
  2910.         mactcpclrsendbuf();
  2911.     }
  2912. #ifdef DUALTCP
  2913.     else if (emdp->conntype == CONN_CUTCP) {
  2914.         clrsendbuf();
  2915.         cls_usr();
  2916.     }
  2917. #endif
  2918.     else if (emdp->conntype == CONN_SERD) {
  2919.         cls_usr();
  2920.     }
  2921. }
  2922.  
  2923.  
  2924. /* TODO move
  2925.     send a TCP urgent packet */
  2926.  
  2927. dotcpurgent()
  2928. {
  2929. #ifdef DUALTCP
  2930.     if (emdp->conntype == CONN_CUTCP)
  2931.         tcpurgent();
  2932. #endif
  2933. }
  2934.  
  2935.  
  2936. tcpmenu()
  2937. {
  2938.     AppendMenu(menu[NETWORKMENU], "\P ");    /* add GATEADDR to menu */
  2939. }
  2940.  
  2941.  
  2942. /* check the font size current being used */
  2943.  
  2944. setfontsizemenu(fsize)
  2945. int fsize;
  2946. {
  2947.     char name[NAMESIZE];
  2948.     short count;
  2949.     
  2950.     if (environs.systemVersion == 0)
  2951.         /* can't handle the nested menu */
  2952.         return;
  2953.  
  2954.     for (count = 1; count <= FONTSIZECOUNT; count++) {
  2955.         CheckItem(menu[FSIZEMENU], count, FALSE);
  2956.         GetItem(menu[FSIZEMENU], count, name);
  2957.         ptoc(name);
  2958.         if (fsize == atoi(name)) {
  2959.             /* this is the newly selected font */
  2960.             CheckItem(menu[FSIZEMENU], count, TRUE);
  2961.         }
  2962.     }
  2963. }
  2964.  
  2965.  
  2966.